* [PATCH 1/3] git reset --hard gives clean working tree
[not found] <Message-Id=xmqqio26nqk8.fsf@gitster.mtv.corp.google.com>
@ 2016-02-11 16:16 ` tboegi
2016-02-11 18:49 ` Junio C Hamano
2016-02-11 16:16 ` [PATCH 2/3] Factor out convert_cmp_checkout() into convert.c tboegi
2016-02-11 16:16 ` [PATCH 3/3] convert.c: Optimize convert_cmp_checkout() for changed file len tboegi
2 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-02-11 16:16 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
We define the working tree file is clean if either:
* the result of running convert_to_git() on the working tree
contents matches what is in the index (because that would mean
doing another "git add" on the path is a no-op); OR
* the result of running convert_to_working_tree() on the content
in the index matches what is in the working tree (because that
would mean doing another "git checkout -f" on the path is a
no-op).
Add an extra check in ce_compare_data() in read_cache.c, and adjust
the test cases in t0025:
When a file has CRLF in the index, and is checked out into the working tree,
but left unchabged, it is not normalized at the next commit.
Whenever the file is changed in the working tree, a line is added/deleted
or dos2unix is run, it may be normalized at the next commit,
depending on .gitattributes.
This patch is a result of a longer discussion on the mailing list,
how to fix the flaky t0025.
Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
This is my attempt to help to fix flaky t0025:
- steal the code from Junio
- Add test case, change the existing if needed.
- Spice with some optimizations
The commit messages may be in the state "improvable".
read-cache.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++
t/t0025-crlf-auto.sh | 57 +++++++++++++++++++++++++++++++++++++++++++++------
2 files changed, 109 insertions(+), 6 deletions(-)
diff --git a/read-cache.c b/read-cache.c
index 394ce14..2948b8f 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -156,17 +156,75 @@ void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
ce_mark_uptodate(ce);
}
+/*
+ * Compare the data in buf with the data in the file pointed by fd and
+ * return 0 if they are identical, and non-zero if they differ.
+ */
+static int compare_with_fd(const char *input, ssize_t len, int fd)
+{
+ for (;;) {
+ char buf[1024 * 16];
+ ssize_t chunk_len, read_len;
+
+ chunk_len = sizeof(buf) < len ? sizeof(buf) : len;
+ read_len = xread(fd, buf, chunk_len ? chunk_len : 1);
+
+ if (!read_len)
+ /* EOF on the working tree file */
+ return !len ? 0 : -1;
+
+ if (!len)
+ /* we expected there is nothing left */
+ return -1;
+
+ if (memcmp(buf, input, read_len))
+ return -1;
+ input += read_len;
+ len -= read_len;
+ }
+}
+
static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
{
int match = -1;
int fd = open(ce->name, O_RDONLY);
+ /*
+ * Would another "git add" on the path change what is in the
+ * index for the path?
+ */
if (fd >= 0) {
unsigned char sha1[20];
if (!index_fd(sha1, fd, st, OBJ_BLOB, ce->name, 0))
match = hashcmp(sha1, ce->sha1);
/* index_fd() closed the file descriptor already */
}
+ if (!match)
+ return match;
+
+ /*
+ * Would another "git checkout -f" out of the index change
+ * what is in the working tree file?
+ */
+ fd = open(ce->name, O_RDONLY);
+ if (fd >= 0) {
+ enum object_type type;
+ unsigned long size;
+ void *data = read_sha1_file(ce->sha1, &type, &size);
+
+ if (type == OBJ_BLOB) {
+ struct strbuf worktree = STRBUF_INIT;
+ if (convert_to_working_tree(ce->name, data, size,
+ &worktree)) {
+ free(data);
+ data = strbuf_detach(&worktree, &size);
+ }
+ if (!compare_with_fd(data, size, fd))
+ match = 0;
+ }
+ free(data);
+ close(fd);
+ }
return match;
}
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index c164b46..4a7e5c0 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -14,6 +14,8 @@ test_expect_success setup '
for w in Hello world how are you; do echo $w; done >LFonly &&
for w in I am very very fine thank you; do echo ${w}Q; done | q_to_cr >CRLFonly &&
+ cp CRLFonly CRLFonly1 &&
+ cp CRLFonly CRLFonly2 &&
for w in Oh here is a QNUL byte how alarming; do echo ${w}; done | q_to_nul >LFwithNUL &&
git add . &&
@@ -23,6 +25,28 @@ test_expect_success setup '
CRLFonly=$(git rev-parse HEAD:CRLFonly) &&
LFwithNUL=$(git rev-parse HEAD:LFwithNUL) &&
+ cp CRLFonly CRLFonly.orig &&
+ for w in I am very very fine thank YOU; do echo ${w}Q; done | q_to_cr >CRLFonly.changed &&
+ cat >expnorm <<-EOF &&
+ MIQ
+ MamQ
+ MveryQ
+ MveryQ
+ MfineQ
+ MthankQ
+ MyouQ
+ PI
+ Pam
+ Pvery
+ Pvery
+ Pfine
+ Pthank
+ PYOU
+ EOF
+ cat >expunor <<-EOF &&
+ MyouQ
+ PYOUQ
+ EOF
echo happy.
'
@@ -39,7 +63,7 @@ test_expect_success 'default settings cause no changes' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'crlf=true causes a CRLF file to be normalized' '
+test_expect_success 'crlf=true causes an unchanged CRLF file not to be normalized' '
# Backwards compatibility check
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
@@ -49,10 +73,10 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
-test_expect_success 'text=true causes a CRLF file to be normalized' '
+test_expect_success 'text=true causes an unchanged CRLF file not to be normalized' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
echo "CRLFonly text" > .gitattributes &&
@@ -61,7 +85,7 @@ test_expect_success 'text=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '
@@ -114,7 +138,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
+test_expect_success 'text=auto, autocrlf=true causes an unchanged CRLF file not to be normalized' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
git config core.autocrlf true &&
@@ -126,7 +150,7 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
LFonlydiff=$(git diff LFonly) &&
CRLFonlydiff=$(git diff CRLFonly) &&
LFwithNULdiff=$(git diff LFwithNUL) &&
- test -z "$LFonlydiff" -a -n "$CRLFonlydiff" -a -z "$LFwithNULdiff"
+ test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
@@ -152,4 +176,25 @@ test_expect_success 'eol=crlf _does_ normalize binary files' '
test -z "$LFwithNULdiff"
'
+test_expect_success 'crlf=true causes a changed CRLF file to be normalized' '
+ git config core.autocrlf false &&
+ echo "CRLFonly1 crlf" > .gitattributes &&
+ # Note, "normalized" means that git will normalize it if added
+ cp CRLFonly.changed CRLFonly1 &&
+ git add CRLFonly1 &&
+ git diff --cached CRLFonly1 |
+ tr "\015" Q | sed -ne "/^[+-][a-zA-Z]/p" | tr "+-" PM >actual1 &&
+ test_cmp expnorm actual1
+'
+
+test_expect_success 'autocrlf=true causes a changed CRLF file not to be normalized' '
+ git config core.autocrlf true &&
+ echo > .gitattributes &&
+ # Note, "normalized" means that git will normalize it if added
+ cp CRLFonly.changed CRLFonly2 &&
+ git add CRLFonly2 &&
+ git diff --cached CRLFonly2 |
+ tr "\015" Q | sed -ne "/^[+-][a-zA-Z]/p" | tr "+-" PM >actual2 &&
+ test_cmp expunor actual2
+'
test_done
--
2.7.0.303.g2c4f448.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH 2/3] Factor out convert_cmp_checkout() into convert.c
[not found] <Message-Id=xmqqio26nqk8.fsf@gitster.mtv.corp.google.com>
2016-02-11 16:16 ` [PATCH 1/3] git reset --hard gives clean working tree tboegi
@ 2016-02-11 16:16 ` tboegi
2016-02-11 16:16 ` [PATCH 3/3] convert.c: Optimize convert_cmp_checkout() for changed file len tboegi
2 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-02-11 16:16 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Factor out the code from read_cache.c retrieveing the blob, converting to
worktree format and comparing with the file on disc into convert.c.
Move static compare_with_fd() from read_cache.c to convert.c as well.
Add a shortcut in convert_cmp_checkout(): When no converting attributes are
set, no filters defined and core.autocrlf is false, skip the additional compare.
To avoid that attributes needs to be searched on the file system twice, change
convert_to_working_tree_internal() to take an additional parameter conv_attrs*.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
cache.h | 2 ++
convert.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++---------
read-cache.c | 21 +--------------
3 files changed, 78 insertions(+), 32 deletions(-)
diff --git a/cache.h b/cache.h
index 22ef4f1..a0dfa5e 100644
--- a/cache.h
+++ b/cache.h
@@ -568,6 +568,8 @@ extern int ce_same_name(const struct cache_entry *a, const struct cache_entry *b
extern void set_object_name_for_intent_to_add_entry(struct cache_entry *ce);
extern int index_name_is_other(const struct index_state *, const char *, int);
extern void *read_blob_data_from_index(struct index_state *, const char *, unsigned long *);
+extern int convert_cmp_checkout(const char *);
+
/* do stat comparison even if CE_VALID is true */
#define CE_MATCH_IGNORE_VALID 01
diff --git a/convert.c b/convert.c
index 18af685..9cbc62c 100644
--- a/convert.c
+++ b/convert.c
@@ -217,6 +217,34 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
}
}
+/*
+ * Compare the data in buf with the data in the file pointed by fd and
+ * return 0 if they are identical, and non-zero if they differ.
+ */
+static int compare_with_fd(const char *input, unsigned long len, int fd)
+{
+ for (;;) {
+ char buf[1024 * 16];
+ ssize_t chunk_len, read_len;
+
+ chunk_len = sizeof(buf) < len ? sizeof(buf) : len;
+ read_len = xread(fd, buf, chunk_len ? chunk_len : 1);
+
+ if (!read_len)
+ /* EOF on the working tree file */
+ return !len ? 0 : -1;
+
+ if (!len)
+ /* we expected there is nothing left */
+ return -1;
+
+ if (memcmp(buf, input, read_len))
+ return -1;
+ input += read_len;
+ len -= read_len;
+ }
+}
+
static int has_cr_in_index(const char *path)
{
unsigned long sz;
@@ -807,6 +835,37 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
ca->crlf_action = CRLF_AUTO_INPUT;
}
+int convert_cmp_checkout(const char *path)
+{
+ struct conv_attrs ca;
+ int match = -1; /* no match */
+ int fd;
+ convert_attrs(&ca, path);
+ if (ca.crlf_action == CRLF_BINARY && !ca.drv && !ca.ident)
+ return -1; /* No eol conversion, no ident, no filter */
+
+ fd = open(path, O_RDONLY);
+ if (fd >= 0) {
+ unsigned long sz;
+ void *data;
+ data = read_blob_data_from_cache(path, &sz);
+ if (!data)
+ match = -1;
+ else {
+ struct strbuf worktree = STRBUF_INIT;
+ if (convert_to_working_tree(path, data, sz, &worktree)) {
+ free(data);
+ data = strbuf_detach(&worktree, &sz);
+ }
+ if (!compare_with_fd(data, sz, fd))
+ match = 0;
+ }
+ free(data);
+ close(fd);
+ }
+ return match;
+}
+
int would_convert_to_git_filter_fd(const char *path)
{
struct conv_attrs ca;
@@ -898,22 +957,21 @@ void convert_to_git_filter_fd(const char *path, int fd, struct strbuf *dst,
ident_to_git(path, dst->buf, dst->len, dst, ca.ident);
}
-static int convert_to_working_tree_internal(const char *path, const char *src,
+static int convert_to_working_tree_internal(const char *path,
+ struct conv_attrs *ca,
+ const char *src,
size_t len, struct strbuf *dst,
int normalizing)
{
int ret = 0, ret_filter = 0;
const char *filter = NULL;
int required = 0;
- struct conv_attrs ca;
-
- convert_attrs(&ca, path);
- if (ca.drv) {
- filter = ca.drv->smudge;
- required = ca.drv->required;
+ if (ca->drv) {
+ filter = ca->drv->smudge;
+ required = ca->drv->required;
}
- ret |= ident_to_worktree(path, src, len, dst, ca.ident);
+ ret |= ident_to_worktree(path, src, len, dst, ca->ident);
if (ret) {
src = dst->buf;
len = dst->len;
@@ -923,7 +981,7 @@ static int convert_to_working_tree_internal(const char *path, const char *src,
* is a smudge filter. The filter might expect CRLFs.
*/
if (filter || !normalizing) {
- ret |= crlf_to_worktree(path, src, len, dst, ca.crlf_action);
+ ret |= crlf_to_worktree(path, src, len, dst, ca->crlf_action);
if (ret) {
src = dst->buf;
len = dst->len;
@@ -932,19 +990,24 @@ static int convert_to_working_tree_internal(const char *path, const char *src,
ret_filter = apply_filter(path, src, len, -1, dst, filter);
if (!ret_filter && required)
- die("%s: smudge filter %s failed", path, ca.drv->name);
+ die("%s: smudge filter %s failed", path, ca->drv->name);
return ret | ret_filter;
}
int convert_to_working_tree(const char *path, const char *src, size_t len, struct strbuf *dst)
{
- return convert_to_working_tree_internal(path, src, len, dst, 0);
+ struct conv_attrs ca;
+ convert_attrs(&ca, path);
+ return convert_to_working_tree_internal(path, &ca, src, len, dst, 0);
}
int renormalize_buffer(const char *path, const char *src, size_t len, struct strbuf *dst)
{
- int ret = convert_to_working_tree_internal(path, src, len, dst, 1);
+ struct conv_attrs ca;
+ int ret;
+ convert_attrs(&ca, path);
+ ret = convert_to_working_tree_internal(path, &ca, src, len, dst, 1);
if (ret) {
src = dst->buf;
len = dst->len;
diff --git a/read-cache.c b/read-cache.c
index 2948b8f..35481b0 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -206,26 +206,7 @@ static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
* Would another "git checkout -f" out of the index change
* what is in the working tree file?
*/
- fd = open(ce->name, O_RDONLY);
- if (fd >= 0) {
- enum object_type type;
- unsigned long size;
- void *data = read_sha1_file(ce->sha1, &type, &size);
-
- if (type == OBJ_BLOB) {
- struct strbuf worktree = STRBUF_INIT;
- if (convert_to_working_tree(ce->name, data, size,
- &worktree)) {
- free(data);
- data = strbuf_detach(&worktree, &size);
- }
- if (!compare_with_fd(data, size, fd))
- match = 0;
- }
- free(data);
- close(fd);
- }
- return match;
+ return convert_cmp_checkout(ce->name);
}
static int ce_compare_link(const struct cache_entry *ce, size_t expected_size)
--
2.7.0.303.g2c4f448.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH 3/3] convert.c: Optimize convert_cmp_checkout() for changed file len
[not found] <Message-Id=xmqqio26nqk8.fsf@gitster.mtv.corp.google.com>
2016-02-11 16:16 ` [PATCH 1/3] git reset --hard gives clean working tree tboegi
2016-02-11 16:16 ` [PATCH 2/3] Factor out convert_cmp_checkout() into convert.c tboegi
@ 2016-02-11 16:16 ` tboegi
2 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-02-11 16:16 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Whenever the size of data from convert_to_working_tree() is different
from the length of the file in the working tree, the must be different
and compare_with_fd() can be skipped.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 34 +++++++++++++++++-----------------
1 file changed, 17 insertions(+), 17 deletions(-)
diff --git a/convert.c b/convert.c
index 9cbc62c..2593367 100644
--- a/convert.c
+++ b/convert.c
@@ -838,30 +838,30 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
int convert_cmp_checkout(const char *path)
{
struct conv_attrs ca;
- int match = -1; /* no match */
- int fd;
+ size_t sz;
+ void *data;
+ int match = -1; /* no match, or unknown */
convert_attrs(&ca, path);
if (ca.crlf_action == CRLF_BINARY && !ca.drv && !ca.ident)
return -1; /* No eol conversion, no ident, no filter */
- fd = open(path, O_RDONLY);
- if (fd >= 0) {
- unsigned long sz;
- void *data;
- data = read_blob_data_from_cache(path, &sz);
- if (!data)
- match = -1;
- else {
- struct strbuf worktree = STRBUF_INIT;
- if (convert_to_working_tree(path, data, sz, &worktree)) {
- free(data);
- data = strbuf_detach(&worktree, &sz);
+ data = read_blob_data_from_cache(path, &sz);
+ if (data) {
+ struct strbuf worktree = STRBUF_INIT;
+ struct stat st;
+ if (convert_to_working_tree(path, data, sz, &worktree)) {
+ free(data);
+ data = strbuf_detach(&worktree, &sz);
+ }
+ if (!lstat(path, &st) && sz == xsize_t(st.st_size)) {
+ int fd = open(path, O_RDONLY);
+ if (fd >= 0) {
+ if (!compare_with_fd(data, sz, fd))
+ match = 0;
+ close(fd);
}
- if (!compare_with_fd(data, sz, fd))
- match = 0;
}
free(data);
- close(fd);
}
return match;
}
--
2.7.0.303.g2c4f448.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH 1/3] git reset --hard gives clean working tree
2016-02-11 16:16 ` [PATCH 1/3] git reset --hard gives clean working tree tboegi
@ 2016-02-11 18:49 ` Junio C Hamano
2016-03-05 7:23 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-02-11 18:49 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> We define the working tree file is clean if either:
>
> * the result of running convert_to_git() on the working tree
> contents matches what is in the index (because that would mean
> doing another "git add" on the path is a no-op); OR
>
> * the result of running convert_to_working_tree() on the content
> in the index matches what is in the working tree (because that
> would mean doing another "git checkout -f" on the path is a
> no-op).
>
> Add an extra check in ce_compare_data() in read_cache.c, and adjust
> the test cases in t0025:
> When a file has CRLF in the index, and is checked out into the working tree,
> but left unchabged, it is not normalized at the next commit.
> Whenever the file is changed in the working tree, a line is added/deleted
> or dos2unix is run, it may be normalized at the next commit,
> depending on .gitattributes.
>
> This patch is a result of a longer discussion on the mailing list,
> how to fix the flaky t0025.
Currently, the codepaths that want to stop if it would lose
information from the index and/or the working tree for the path run
an equivalent of "diff-files path" to see there is any difference.
This indeed is overly strict for a path that has contents in the
index that wouldn't have been created by "clean" conversion (I am
using this word to mean anything convert_to_git() does, not limited
to the "clean" filter).
And it is sensible to allow them to proceed if the contents in the
working tree file for the path match what would be created by
"smudge" conversion of the contents in the index.
But breaking "diff-files" is not the right way to do so. Teaching
"Am I safe to proceed" callers that paths that do not pass
"diff-files" test may still be safe to work on is.
I did not continue the approach I illustrated because I realized and
finally convinced myself that touching ce_compare_data() is a wrong
solution--it breaks "diff-files".
Imagine if you have contents in the index that wouldn't have been
left by a "clean" conversion of what is in the working tree. You
then run "git checkout -f". Now the contents in the working tree
will still not convert back to what is in the index with another
"clean" conversion, but it should pass the "Am I safe to proceed"
check, namely, it matches what convert_to_worktree() would give.
But imagine further what would happen when you add an extra blank
line at the end of the file in the working tree (i.e. "echo >>file")
and then run "diff-files -p".
The illustration patch I gave broke "diff-files" in such a way that
before such an addition of an extra blank line, it would have said
"No changes". And if you run "diff-files" after adding that extra
blank line, you will see whole bunch of changes, not just the extra
blank line at the end.
This is sufficient to convince me that the approach is broken.
The stolen code from me to do the reverse conversion and comparison
may still be reusable, but it should not go to ce_compare_data().
Such a path that has contents in the index that does not match what
"clean"-ing the working tree contents would give us _must_ remain
dirty and return DATA_CHANGED to ie_modified().
I think the right approach to solve this (assuming that this is
worth solving, which I am yet not sure) would go like this:
* Allocate an extra bit in options passed to ie_match_stat(). When
this bit is set, allow it to perform the "Smudge the contents in
the index and compare it with the working tree contents" check
and declare "You can proceed, nothing will be lost by touching
the working tree", but never mark the cache entry up-to-date
while doing so.
* Pass the flag from callers that want this semantics,
e.g. verify_uptodate() in unpack-trees.c, but not from
"diff-files".
It probably is necessary to enable the new behaviour _only_ when a
new command line option explicitly asks for it, because
- this is rather expensive;
- this will have to be done for pretty-much all dirty paths, not
just the ones that the additional reverse test would declare
clean;
- most normal people would not have such a broken data in the
index;
- those who has such a broken data would want to "fix" the data in
the index as a tree-wide flag day correction event, after which
they do not want to pay the penalty of doing this reverse
comparison check all the time; and
- requiring an explicit command line option is not a burden when
the user _does_ want to do such a one-time "fix".
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH 1/3] git reset --hard gives clean working tree
2016-02-11 18:49 ` Junio C Hamano
@ 2016-03-05 7:23 ` Torsten Bögershausen
2016-03-05 8:05 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Torsten Bögershausen @ 2016-03-05 7:23 UTC (permalink / raw)
To: Junio C Hamano, tboegi; +Cc: git
On 11.02.16 19:49, Junio C Hamano wrote:
> tboegi@web.de writes:
>
>> From: Torsten Bögershausen <tboegi@web.de>
>>
>> We define the working tree file is clean if either:
>>
>> * the result of running convert_to_git() on the working tree
>> contents matches what is in the index (because that would mean
>> doing another "git add" on the path is a no-op); OR
>>
>> * the result of running convert_to_working_tree() on the content
>> in the index matches what is in the working tree (because that
>> would mean doing another "git checkout -f" on the path is a
>> no-op).
>>
>> Add an extra check in ce_compare_data() in read_cache.c, and adjust
>> the test cases in t0025:
>> When a file has CRLF in the index, and is checked out into the working tree,
>> but left unchabged, it is not normalized at the next commit.
>> Whenever the file is changed in the working tree, a line is added/deleted
>> or dos2unix is run, it may be normalized at the next commit,
>> depending on .gitattributes.
>>
>> This patch is a result of a longer discussion on the mailing list,
>> how to fix the flaky t0025.
> Currently, the codepaths that want to stop if it would lose
> information from the index and/or the working tree for the path run
> an equivalent of "diff-files path" to see there is any difference.
> This indeed is overly strict for a path that has contents in the
> index that wouldn't have been created by "clean" conversion (I am
> using this word to mean anything convert_to_git() does, not limited
> to the "clean" filter).
>
> And it is sensible to allow them to proceed if the contents in the
> working tree file for the path match what would be created by
> "smudge" conversion of the contents in the index.
>
> But breaking "diff-files" is not the right way to do so. Teaching
> "Am I safe to proceed" callers that paths that do not pass
> "diff-files" test may still be safe to work on is.
>
> I did not continue the approach I illustrated because I realized and
> finally convinced myself that touching ce_compare_data() is a wrong
> solution--it breaks "diff-files".
>
> Imagine if you have contents in the index that wouldn't have been
> left by a "clean" conversion of what is in the working tree. You
> then run "git checkout -f". Now the contents in the working tree
> will still not convert back to what is in the index with another
> "clean" conversion, but it should pass the "Am I safe to proceed"
> check, namely, it matches what convert_to_worktree() would give.
>
> But imagine further what would happen when you add an extra blank
> line at the end of the file in the working tree (i.e. "echo >>file")
> and then run "diff-files -p".
>
> The illustration patch I gave broke "diff-files" in such a way that
> before such an addition of an extra blank line, it would have said
> "No changes". And if you run "diff-files" after adding that extra
> blank line, you will see whole bunch of changes, not just the extra
> blank line at the end.
>
> This is sufficient to convince me that the approach is broken.
[]
Would something like this make sense?
(The main part is in diff.c, the rest needs some polishing)
commit e494c31fd2f0f8a638ff14d1b8ae3f3a6d56a107
Author: Torsten Bögershausen <tboegi@web.de>
Date: Sat Mar 5 07:51:08 2016 +0100
Text files needs to be normalized before diffing
Whenever a text file is stored with CRLF in the index, Git changes
CRLF into LF at the next commit.
(text file means the attribute "text" or "crlf" of "eol" is set).
"git diff" reports that all lines with CRLF in the index as changed to LF.
After cloning a repo, the work tree is not considered clean by Git, even if
the user didn't change a single line.
Avoid to report lines as changed by converting the content from the index into
LF before running diff.
diff --git a/convert.c b/convert.c
index f524b8d..af8248d 100644
--- a/convert.c
+++ b/convert.c
@@ -231,9 +231,9 @@ static int has_cr_in_index(const char *path)
return has_cr;
}
-static int crlf_to_git(const char *path, const char *src, size_t len,
- struct strbuf *buf,
- enum crlf_action crlf_action, enum safe_crlf checksafe)
+static int crlf_to_git_internal(const char *path, const char *src, size_t len,
+ struct strbuf *buf,
+ enum crlf_action crlf_action, enum safe_crlf checksafe)
{
struct text_stat stats;
char *dst;
@@ -852,7 +852,17 @@ const char *get_convert_attr_ascii(const char *path)
return "";
}
-int convert_to_git(const char *path, const char *src, size_t len,
+int convert_crlf_to_git(const char *path, const char *src, size_t len,
+ struct strbuf *buf,
+ enum safe_crlf checksafe)
+{
+ struct conv_attrs ca;
+ convert_attrs(&ca, path);
+ return crlf_to_git_internal(path, src, len, buf,
+ ca.crlf_action, checksafe);
+
+}
+ int convert_to_git(const char *path, const char *src, size_t len,
struct strbuf *dst, enum safe_crlf checksafe)
{
int ret = 0;
@@ -874,7 +884,7 @@ 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, ca.crlf_action, checksafe);
+ ret |= crlf_to_git_internal(path, src, len, dst, ca.crlf_action, checksafe);
if (ret && dst) {
src = dst->buf;
len = dst->len;
@@ -894,7 +904,7 @@ void convert_to_git_filter_fd(const char *path, int fd, struct strbuf *dst,
if (!apply_filter(path, NULL, 0, fd, dst, ca.drv->clean))
die("%s: clean filter '%s' failed", path, ca.drv->name);
- crlf_to_git(path, dst->buf, dst->len, dst, ca.crlf_action, checksafe);
+ crlf_to_git_internal(path, dst->buf, dst->len, dst, ca.crlf_action, checksafe);
ident_to_git(path, dst->buf, dst->len, dst, ca.ident);
}
diff --git a/convert.h b/convert.h
index ccf436b..11eff02 100644
--- a/convert.h
+++ b/convert.h
@@ -52,6 +52,9 @@ extern void convert_to_git_filter_fd(const char *path, int fd,
struct strbuf *dst,
enum safe_crlf checksafe);
extern int would_convert_to_git_filter_fd(const char *path);
+extern int convert_crlf_to_git(const char *path, const char *src, size_t len,
+ struct strbuf *buf,
+ enum safe_crlf checksafe);
/*****************************************************************
*
diff --git a/diff.c b/diff.c
index 059123c..8710a36 100644
--- a/diff.c
+++ b/diff.c
@@ -2730,6 +2730,7 @@ static int diff_populate_gitlink(struct diff_filespec *s, int size_only)
*/
int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
{
+ struct strbuf buf = STRBUF_INIT;
int size_only = flags & CHECK_SIZE_ONLY;
int err = 0;
/*
@@ -2756,7 +2757,6 @@ int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
if (!s->sha1_valid ||
reuse_worktree_file(s->path, s->sha1, 0)) {
- struct strbuf buf = STRBUF_INIT;
struct stat st;
int fd;
@@ -2826,6 +2826,12 @@ int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
if (!s->data)
die("unable to read %s", sha1_to_hex(s->sha1));
s->should_free = 1;
+ if (convert_crlf_to_git(s->path, s->data, s->size,
+ &buf, SAFE_CRLF_FALSE)) {
+ size_t size = 0;
+ s->data = strbuf_detach(&buf, &size);
+ s->size = size;
+ }
}
return 0;
}
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index c164b46..dd1645b 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 "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'crlf=true causes a CRLF file to be normalized' '
+test_expect_success 'crlf=true on a CRLF file git diff is empty' '
# Backwards compatibility check
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
@@ -49,19 +49,18 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
-test_expect_success 'text=true causes a CRLF file to be normalized' '
+test_expect_success 'eol=crlf gives CRLF with no diff' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
- echo "CRLFonly text" > .gitattributes &&
+ echo "CRLFonly text eol=crlf" > .gitattributes &&
git read-tree --reset -u HEAD &&
-
- # Note, "normalized" means that git will normalize it if added
- has_cr CRLFonly &&
- CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ >expect &&
+ git diff CRLFonly | tr "\015" Q >actual &&
+ test_cmp expect actual &&
+ has_cr CRLFonly
'
test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '
@@ -114,7 +113,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
+test_expect_success 'text=auto, autocrlf=true git diff is empty' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
git config core.autocrlf true &&
@@ -126,7 +125,7 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
LFonlydiff=$(git diff LFonly) &&
CRLFonlydiff=$(git diff CRLFonly) &&
LFwithNULdiff=$(git diff LFwithNUL) &&
- test -z "$LFonlydiff" -a -n "$CRLFonlydiff" -a -z "$LFwithNULdiff"
+ test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH 1/3] git reset --hard gives clean working tree
2016-03-05 7:23 ` Torsten Bögershausen
@ 2016-03-05 8:05 ` Junio C Hamano
2016-03-05 8:27 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-03-05 8:05 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
> On 11.02.16 19:49, Junio C Hamano wrote:
>
>> I did not continue the approach I illustrated because I realized and
>> finally convinced myself that touching ce_compare_data() is a wrong
>> solution--it breaks "diff-files".
>>
>> Imagine if you have contents in the index that wouldn't have been
>> left by a "clean" conversion of what is in the working tree. You
>> then run "git checkout -f". Now the contents in the working tree
>> will still not convert back to what is in the index with another
>> "clean" conversion, but it should pass the "Am I safe to proceed"
>> check, namely, it matches what convert_to_worktree() would give.
>>
>> But imagine further what would happen when you add an extra blank
>> line at the end of the file in the working tree (i.e. "echo >>file")
>> and then run "diff-files -p".
>>
>> The illustration patch I gave broke "diff-files" in such a way that
>> before such an addition of an extra blank line, it would have said
>> "No changes". And if you run "diff-files" after adding that extra
>> blank line, you will see whole bunch of changes, not just the extra
>> blank line at the end.
>>
>> This is sufficient to convince me that the approach is broken.
> []
> Would something like this make sense?
> (The main part is in diff.c, the rest needs some polishing)
>
> commit e494c31fd2f0f8a638ff14d1b8ae3f3a6d56a107
> Author: Torsten Bögershausen <tboegi@web.de>
> Date: Sat Mar 5 07:51:08 2016 +0100
>
> Text files needs to be normalized before diffing
>
> Whenever a text file is stored with CRLF in the index, Git changes
> CRLF into LF at the next commit.
> (text file means the attribute "text" or "crlf" of "eol" is set).
I do not think I can endorse this approach, as I cannot explain why
it could possibly make sense to treat as if CRLF conversion is
somehow special among all the convert_to_git()/convert_to_worktree()
conversions, which your patch does to the diff code.
Comparisons between contents from two tree objects and comparisons
between contents from a tree object and the index must happen
without conversion, and comparisons between contents from the tree
in the HEAD commit and contents from the working tree must be done
in line with the HEAD vs index comparison to serve as a preview of
what would happen after adding the contents taken from the working
tree to the index, which means we should compare what is in the
index (without conversion) and the result of running the whole
convert_to_git() conversion on what is in the working tree. It
feels fundamentally wrong to apply only CRLF conversion without any
other conversion, whether the direction of the conversion is from
worktree to git or the other way around, when comparing two things.
When the user has CRLF data in the index and the user tell the
attribute system so that the next "add" would result in "fixing" the
indexed lines to be terminated with LF, "diff-files" _should_ show
that correction as a change, I think.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH 1/3] git reset --hard gives clean working tree
2016-03-05 8:05 ` Junio C Hamano
@ 2016-03-05 8:27 ` Torsten Bögershausen
2016-03-05 21:18 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Torsten Bögershausen @ 2016-03-05 8:27 UTC (permalink / raw)
To: Junio C Hamano, Torsten Bögershausen; +Cc: git
> I do not think I can endorse this approach, as I cannot explain why
> it could possibly make sense to treat as if CRLF conversion is
> somehow special among all the convert_to_git()/convert_to_worktree()
> conversions, which your patch does to the diff code.
>
> Comparisons between contents from two tree objects and comparisons
> between contents from a tree object and the index must happen
> without conversion, and comparisons between contents from the tree
> in the HEAD commit and contents from the working tree must be done
> in line with the HEAD vs index comparison to serve as a preview of
> what would happen after adding the contents taken from the working
> tree to the index, which means we should compare what is in the
> index (without conversion) and the result of running the whole
> convert_to_git() conversion on what is in the working tree. It
> feels fundamentally wrong to apply only CRLF conversion without any
> other conversion, whether the direction of the conversion is from
> worktree to git or the other way around, when comparing two things.
>
> When the user has CRLF data in the index and the user tell the
> attribute system so that the next "add" would result in "fixing" the
> indexed lines to be terminated with LF, "diff-files" _should_ show
> that correction as a change, I think.
Fair enough.
There are 2 users here:
User 1 commits files with CRLF into the index, and later decides
to set the "text eol=crlf" attribute on it, without normalizing the repo.
User 2 does a simple "git clone", which includes checkout.
Running "git diff" tells user 2, that his work tree is dirty.
My conclusion is, that we could suppress the normalization for text files,
(as we do it for core.autocrlf with the new safer CRLF handling)
meaning that "git diff" and "git status" is clean and that files stay with CRLF
in the index.
Does this make sense ?
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH 1/3] git reset --hard gives clean working tree
2016-03-05 8:27 ` Torsten Bögershausen
@ 2016-03-05 21:18 ` Junio C Hamano
2016-03-07 8:14 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-03-05 21:18 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
>> When the user has CRLF data in the index and the user tell the
>> attribute system so that the next "add" would result in "fixing" the
>> indexed lines to be terminated with LF, "diff-files" _should_ show
>> that correction as a change, I think.
> Fair enough.
> There are 2 users here:
> User 1 commits files with CRLF into the index, and later decides
> to set the "text eol=crlf" attribute on it, without normalizing the repo.
>
> User 2 does a simple "git clone", which includes checkout.
> Running "git diff" tells user 2, that his work tree is dirty.
>
> My conclusion is, that we could suppress the normalization for text files,
> (as we do it for core.autocrlf with the new safer CRLF handling)
> meaning that "git diff" and "git status" is clean and that files stay with CRLF
> in the index.
> Does this make sense ?
Your example is for these two users to have conflicting settings on
the line ending, but if user 1 commits files in latin-1 to a project
where in-project data is expected to be UTF-8 and working tree files
can be in latin-1, with necessary conversion done via clean/smudge
filter, the user 2 would see a very similar symptom, wouldn't s/he?
So I am not sure how your example supports a hack that treats CRLF
conversion as something special among other conversions, without
doing anything about clean/smudge filter.
Besides, it is OK if your status and diff says your worktree is
dirty immediately after cloning in such a broken situation, I would
think. In fact, it may even be preferable to do so, in order to
indicate that there is something unusual going on.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH 1/3] git reset --hard gives clean working tree
2016-03-05 21:18 ` Junio C Hamano
@ 2016-03-07 8:14 ` Junio C Hamano
2016-03-07 8:51 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-03-07 8:14 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Junio C Hamano <gitster@pobox.com> writes:
> Besides, it is OK if your status and diff says your worktree is
> dirty immediately after cloning in such a broken situation, I would
> think. In fact, it may even be preferable to do so, in order to
> indicate that there is something unusual going on.
The above needs a bit of clarifying follow-up.
Some operations (e.g. "apply --index" and "checkout another-branch")
want to make sure that the path in the working tree "matches" what
is in the index before proceeding. The reason why they require a
match is because they are going to update what is in the index and
then update what is in the working tree to match the result by
checking the updated index entry out to the working tree--if the
working tree and the index are different before they start their
operation, that means you have some changes you made in the working
tree since you checked it out of the index, and their operation will
lose such changes.
Normally, this verification is done by ce_match_stat() and friends,
whose correct operation relies on an earlier refresh_index(), which
in turn makes sure that the result of running the contents in the
working tree through convert_to_git() matches what is in the index.
When your convert_to_working_tree() and convert_to_git() do not
round-trip, however, the result of convert_to_git() on the working
tree contents would not match what is in the index. That is
inconvenient, and it is something you may want to relax to help such
a broken situation. Immediately after you "git checkout" (or "git
reset --hard"), you haven't made any changes, and you should be able
to "git checkout another" to go to another branch.
For this reason, I am perfectly OK with an approach to teach the
callers that currently use ce_uptodate() as the only way to make
sure that there is no modification to a given path (and refuse to
work on it if ce_uptodate() says the path is modified) that it is
also OK to clobber a path that does not pass the ce_uptodate() check
as long as the result of running convert_to_working_tree() on the
indexed contents matches what is in the working tree. These callers
are currently overly strict and you will be relaxing their overly
strict check to help this broken situation.
Perhaps we can introduce a new function can_clobber() that has the
same function signature as ce_uptodate() and update the callers in
apply and unpack-trees (there may be others) to call it instead when
they want to see if they can clobber the working tree file that
corresponds to the cache entry.
For implementing the can_clobber() function, you can use something
along the lines of compare_with_fd() helper function I introduced in
[1] and do something like this, perhaps.
When I send an illustration patch and say "totally untested", I
usually start from the real source file and send "git diff" output
after making changes to the source file, and I may even have at
least compiled the modified result. The following however is typed
directly into my mail program without touching any existing source
file, so it is truly untested--caveat emptor.
/*
* We are about to do some operation to the index entry, and
* write the result out to the working tree. Would we lose
* some local change that exist only in the working tree by
* doing so? Return 1 if we can safely clobber the working
* tree file (i.e. no changes) and return 0 if we can't (i.e.
* there are some changes).
*/
int can_clobber(struct cache_entry *ce)
{
int fd, match = 0;
enum object_type type;
unsigned long size;
void *data;
/*
* Does another "git add -f" of the path result in the
* identical blob in the index? If so, the working tree
* file is expendable.
*/
if (ce_uptodate(ce))
return 1;
fd = open(ce->name, O_RDONLY);
if (fd < 0)
return 0;
data = read_sha1_file(ce->sha1, &type, &size);
if (type == OBJ_BLOB) {
struct strbuf worktree = STRBUF_INIT;
/*
* Does another "git checkout -- path"
* recreate what we see in the working tree?
* If so, the working tree file is expendable.
*/
if (convert_to_working_tree(ce->name, data, size,
&worktree)) {
free(data);
data = strbuf_detach(&worktree, &size);
}
if (!compare_with_fd(data, size, fd))
match = 1;
}
free(data);
close(fd);
return match;
}
[Reference]
*1* http://thread.gmane.org/gmane.comp.version-control.git/284352/focus=285341
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH 1/3] git reset --hard gives clean working tree
2016-03-07 8:14 ` Junio C Hamano
@ 2016-03-07 8:51 ` Junio C Hamano
2016-03-07 8:58 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-03-07 8:51 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Junio C Hamano <gitster@pobox.com> writes:
> Perhaps we can introduce a new function can_clobber() that has the
> same function signature as ce_uptodate() and update the callers in
> apply and unpack-trees (there may be others) to call it instead when
> they want to see if they can clobber the working tree file that
> corresponds to the cache entry.
By the way, I do not want see ie_match_stat() modified to work like
the can_clobber() I outlined in the previous message, which in turn
means that immediately after "git reset --hard" or "git checkout"
when your convert_to_git() and convert_to_working_tree() do not
roundtrip, you _must_ see differences in "git diff".
This is for (at least) two reasons.
* "git diff" (compare between the index and the working tree) is
meant as a preview of how the indexed contents will be modified
if you did "git add" with what you currently have in your working
tree at the path. In a "conversions do not roundtrip" situation,
your "git add" will be modifying the contents in the index, so we
should actively be showing what modification we will be making.
One way of "fixing" the situation without changing either the
working tree contents or the indexed contents is to fix your
convert-to-git settings to make the conversions round-trip, and
then you would stop seeing the changes you would make when you do
"git add". Not showing any diff when can_clobber() is true but
ce_uptodate() is false would make "git diff" less useful when the
user makes this correction.
* "git add" of a path can legitimately optimize itself by not
adding a path that is ce_uptodate(). Mixing ie_match_stat()
with can_clobber() logic would mark such a "conversions do not
roundtrip" path as ce_uptodate(), and prevent the user from
"fixing" the incorrect index entry by running "git add".
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH 1/3] git reset --hard gives clean working tree
2016-03-07 8:51 ` Junio C Hamano
@ 2016-03-07 8:58 ` Torsten Bögershausen
2016-03-07 22:34 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Torsten Bögershausen @ 2016-03-07 8:58 UTC (permalink / raw)
To: Junio C Hamano, Torsten Bögershausen; +Cc: git
On 03/07/2016 09:51 AM, Junio C Hamano wrote:
> Junio C Hamano <gitster@pobox.com> writes:
>
>> Perhaps we can introduce a new function can_clobber() that has the
>> same function signature as ce_uptodate() and update the callers in
>> apply and unpack-trees (there may be others) to call it instead when
>> they want to see if they can clobber the working tree file that
>> corresponds to the cache entry.
> By the way, I do not want see ie_match_stat() modified to work like
> the can_clobber() I outlined in the previous message, which in turn
> means that immediately after "git reset --hard" or "git checkout"
> when your convert_to_git() and convert_to_working_tree() do not
> roundtrip, you _must_ see differences in "git diff".
>
> This is for (at least) two reasons.
>
> * "git diff" (compare between the index and the working tree) is
> meant as a preview of how the indexed contents will be modified
> if you did "git add" with what you currently have in your working
> tree at the path. In a "conversions do not roundtrip" situation,
> your "git add" will be modifying the contents in the index, so we
> should actively be showing what modification we will be making.
>
> One way of "fixing" the situation without changing either the
> working tree contents or the indexed contents is to fix your
> convert-to-git settings to make the conversions round-trip, and
> then you would stop seeing the changes you would make when you do
> "git add". Not showing any diff when can_clobber() is true but
> ce_uptodate() is false would make "git diff" less useful when the
> user makes this correction.
>
> * "git add" of a path can legitimately optimize itself by not
> adding a path that is ce_uptodate(). Mixing ie_match_stat()
> with can_clobber() logic would mark such a "conversions do not
> roundtrip" path as ce_uptodate(), and prevent the user from
> "fixing" the incorrect index entry by running "git add".
>
Thanks.
OK about "git add" and "git diff".
The major question, at least on my side, is where to hook in
"can_clobber()" ?
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH 1/3] git reset --hard gives clean working tree
2016-03-07 8:58 ` Torsten Bögershausen
@ 2016-03-07 22:34 ` Junio C Hamano
2016-03-29 13:25 ` [PATCH v1 1/7] Make it possible to get sha1 for a path from the index tboegi
` (65 more replies)
0 siblings, 66 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-03-07 22:34 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
> The major question, at least on my side, is where to hook in
> "can_clobber()" ?
There are different ways the existing commands ensure that they do
not lose local modifications.
* Some (like unpack-trees code that is used by "merge") do
refresh_cache() upfront and then ask ce_uptodate() if the
contents in the working tree match the indexed contents.
unpack-trees.c::verify_uptodate_1() has a call to ce_uptodate()
and returns early when true (i.e. if "git add" would result in
the same index entry), but then does a double-check with
ie_match_stat(), which essentially asks the "does an add result
in the same index entry?" again.
* Others (like apply) do not do the tree-wide refresh_cache(), but
asks "does an add result in the same index entry" by calling
ce_match_stat(), which is a thin wrapper to ie_match_stat(), in
builtin/apply.c::verify_index_match().
These places need to learn that there is a case where
ie_match_stat() says "'git add' would change the index, i.e. working
tree file is different" but the working tree file can still be
clobbered because 'checkout' would produce the same contents in the
working tree.
But stepping back a bit, I no longer am sure if such a loosening is
desirable. Imagine that you implemented such loosening and allowed
a patch to be applied to the index (and the result checked out to
the working tree). What would the result of "diff --cached" be
after doing so? Would it contain only the change described in the
patch you just accepted? If that is the case, it would be OK, but
if the change from the patch gets mixed with the "fix incorrectly
recorded data in the index" change that you would have recorded if
you did "git add" from the working tree without applying the patch,
then that would not be a desirable outcome, I would suspect. You
would rather want to first commit the "fix incorrectly recorded data
in the index" as a separate preparatory step and then want to apply
the patch. So...
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH v1 1/7] Make it possible to get sha1 for a path from the index
2016-03-07 22:34 ` Junio C Hamano
@ 2016-03-29 13:25 ` tboegi
2016-03-29 13:28 ` Duy Nguyen
2016-03-29 19:32 ` Eric Sunshine
2016-03-29 13:25 ` [PATCH v1 2/7] convert.c: stream and early out tboegi
` (64 subsequent siblings)
65 siblings, 2 replies; 126+ messages in thread
From: tboegi @ 2016-03-29 13:25 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Factor out the retrival of the sha1 for a given path in
read_blob_data_from_index() into the function get_sha1_from_index().
This will be used in the next commit, when convert.c can do the analyze
for "text=auto" without slurping the whole blob into memory at once.
Add a wrapper definition get_sha1_from_cache().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
cache.h | 3 +++
read-cache.c | 29 ++++++++++++++++++-----------
2 files changed, 21 insertions(+), 11 deletions(-)
diff --git a/cache.h b/cache.h
index b829410..bd1210a 100644
--- a/cache.h
+++ b/cache.h
@@ -379,6 +379,7 @@ extern void free_name_hash(struct index_state *istate);
#define unmerge_cache_entry_at(at) unmerge_index_entry_at(&the_index, at)
#define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)
#define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))
+#define get_sha1_from_cache(path) get_sha1_from_index (&the_index, (path))
#endif
enum object_type {
@@ -1008,6 +1009,8 @@ static inline void *read_sha1_file(const unsigned char *sha1, enum object_type *
return read_sha1_file_extended(sha1, type, size, LOOKUP_REPLACE_OBJECT);
}
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path);
+
/*
* This internal function is only declared here for the benefit of
* lookup_replace_object(). Please do not call it directly.
diff --git a/read-cache.c b/read-cache.c
index d9fb78b..a3ef967 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -2263,13 +2263,27 @@ int index_name_is_other(const struct index_state *istate, const char *name,
void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
{
- int pos, len;
+ const unsigned char *sha1;
unsigned long sz;
enum object_type type;
void *data;
- len = strlen(path);
- pos = index_name_pos(istate, path, len);
+ sha1 = get_sha1_from_index(istate, path);
+ if (!sha1)
+ return NULL;
+ data = read_sha1_file(sha1, &type, &sz);
+ if (!data || type != OBJ_BLOB) {
+ free(data);
+ return NULL;
+ }
+ if (size)
+ *size = sz;
+ return data;
+}
+
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path)
+{
+ int pos = index_name_pos(istate, path, strlen(path));
if (pos < 0) {
/*
* We might be in the middle of a merge, in which
@@ -2285,14 +2299,7 @@ void *read_blob_data_from_index(struct index_state *istate, const char *path, un
}
if (pos < 0)
return NULL;
- data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
- if (!data || type != OBJ_BLOB) {
- free(data);
- return NULL;
- }
- if (size)
- *size = sz;
- return data;
+ return (istate->cache[pos]->sha1);
}
void stat_validity_clear(struct stat_validity *sv)
--
2.8.0.rc2.6.g3847ccb
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v1 2/7] convert.c: stream and early out
2016-03-07 22:34 ` Junio C Hamano
2016-03-29 13:25 ` [PATCH v1 1/7] Make it possible to get sha1 for a path from the index tboegi
@ 2016-03-29 13:25 ` tboegi
2016-03-29 13:25 ` [PATCH v1 3/7] Allow core.autocrlf=input and core.eol=crlf tboegi
` (63 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-03-29 13:25 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When statistics are done for the autocrlf handling, the search in
the content can be stopped, if e.g
- a search for binary is done, and a NUL character is found
- a search for CRLF is done, and the first CRLF is found.
Similar when statistics for binary vs non-binary are gathered:
Whenever a lone CR or NUL is found, the search can be aborted.
When checking out files in "auto" mode, any file that has a "lone CR"
or a CRLF will not be converted, so the search can be aborted early.
Add the new bit, CONVERT_STAT_BITS_ANY_CR,
which is set for either lone CR or CRLF.
Many binary files have a NUL very early (within the first few bytes,
latest within the first 1..2K).
It is often not necessary to load the whole content of a file or blob
into memory.
Use a streaming handling for blobs and files in the worktree.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 162 ++++++++++++++++++++++++++++++++++++++++----------------------
1 file changed, 106 insertions(+), 56 deletions(-)
diff --git a/convert.c b/convert.c
index f524b8d..b6da114 100644
--- a/convert.c
+++ b/convert.c
@@ -3,6 +3,7 @@
#include "run-command.h"
#include "quote.h"
#include "sigchain.h"
+#include "streaming.h"
/*
* convert.c - convert a file when checking it out and checking it in.
@@ -13,10 +14,10 @@
* translation when the "text" attribute or "auto_crlf" option is set.
*/
-/* Stat bits: When BIN is set, the txt bits are unset */
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
+#define CONVERT_STAT_BITS_ANY_CR 0x8
enum crlf_action {
CRLF_UNDEFINED,
@@ -31,30 +32,36 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned nul, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonecr, lonelf, crlf;
/* These are just approximations! */
unsigned printable, nonprintable;
};
-static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
+static void do_gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
{
unsigned long i;
- memset(stats, 0, sizeof(*stats));
-
+ if (!buf || !size)
+ return;
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
+ stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
stats->crlf++;
i++;
- } else
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
+ } else {
stats->lonecr++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+ }
continue;
}
if (c == '\n') {
stats->lonelf++;
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_LF;
continue;
}
if (c == 127)
@@ -67,7 +74,7 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
stats->printable++;
break;
case 0:
- stats->nul++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
/* fall through */
default:
stats->nonprintable++;
@@ -75,6 +82,8 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
}
else
stats->printable++;
+ if (stats->stat_bits & earlyout)
+ break; /* We found what we have been searching for */
}
/* If file ends with EOF then don't count this EOF as non-printable. */
@@ -86,41 +95,63 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
* The same heuristics as diff.c::mmfile_is_binary()
* We treat files with bare CR as binary
*/
-static int convert_is_binary(unsigned long size, const struct text_stat *stats)
+static void convert_nonprintable(struct text_stat *stats)
{
- if (stats->lonecr)
- return 1;
- if (stats->nul)
- return 1;
if ((stats->printable >> 7) < stats->nonprintable)
- return 1;
- return 0;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+}
+
+static void gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
+{
+ memset(stats, 0, sizeof(*stats));
+ do_gather_stats(buf, size, stats, earlyout);
+ convert_nonprintable(stats);
}
-static unsigned int gather_convert_stats(const char *data, unsigned long size)
+
+static unsigned get_convert_stats_sha1(const char *path,
+ unsigned const char *sha1,
+ unsigned earlyout)
{
+ struct git_istream *st;
struct text_stat stats;
- int ret = 0;
- if (!data || !size)
- return 0;
- gather_stats(data, size, &stats);
- if (convert_is_binary(size, &stats))
- ret |= CONVERT_STAT_BITS_BIN;
- if (stats.crlf)
- ret |= CONVERT_STAT_BITS_TXT_CRLF;
- if (stats.lonelf)
- ret |= CONVERT_STAT_BITS_TXT_LF;
+ enum object_type type;
+ unsigned long sz;
- return ret;
+ if (!sha1)
+ return 0;
+ memset(&stats, 0, sizeof(stats));
+ st = open_istream(sha1, &type, &sz, NULL);
+ if (!st) {
+ return 0;
+ }
+ if (type != OBJ_BLOB)
+ goto close_and_exit_i;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read_istream(st, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+close_and_exit_i:
+ close_istream(st);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
}
-static const char *gather_convert_stats_ascii(const char *data, unsigned long size)
+static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned int convert_stats = gather_convert_stats(data, size);
-
+ unsigned mask = CONVERT_STAT_BITS_TXT_LF |
+ CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats) {
+ switch (convert_stats & mask) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -132,24 +163,46 @@ static const char *gather_convert_stats_ascii(const char *data, unsigned long si
}
}
+static unsigned get_convert_stats_wt(const char *path)
+{
+ struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ int fd;
+ memset(&stats, 0, sizeof(stats));
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ return 0;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read(fd, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+ close(fd);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
+}
+
const char *get_cached_convert_stats_ascii(const char *path)
{
- const char *ret;
- unsigned long sz;
- void *data = read_blob_data_from_cache(path, &sz);
- ret = gather_convert_stats_ascii(data, sz);
- free(data);
- return ret;
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(path,
+ get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
}
const char *get_wt_convert_stats_ascii(const char *path)
{
- const char *ret = "";
- struct strbuf sb = STRBUF_INIT;
- if (strbuf_read_file(&sb, path, 0) >= 0)
- ret = gather_convert_stats_ascii(sb.buf, sb.len);
- strbuf_release(&sb);
- return ret;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_wt(path);
+ return convert_stats_ascii(convert_stats);
}
static int text_eol_is_crlf(void)
@@ -219,16 +272,11 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
static int has_cr_in_index(const char *path)
{
- unsigned long sz;
- void *data;
- int has_cr;
-
- data = read_blob_data_from_cache(path, &sz);
- if (!data)
- return 0;
- has_cr = memchr(data, '\r', sz) != NULL;
- free(data);
- return has_cr;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_sha1(path,
+ get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_ANY_CR);
+ return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -249,10 +297,10 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
@@ -309,11 +357,13 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
+
if (!len || output_eol(crlf_action) != EOL_CRLF)
return 0;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, earlyout);
/* No "naked" LF? Nothing to convert, regardless. */
if (!stats.lonelf)
@@ -327,7 +377,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
}
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
}
--
2.8.0.rc2.6.g3847ccb
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v1 3/7] Allow core.autocrlf=input and core.eol=crlf
2016-03-07 22:34 ` Junio C Hamano
2016-03-29 13:25 ` [PATCH v1 1/7] Make it possible to get sha1 for a path from the index tboegi
2016-03-29 13:25 ` [PATCH v1 2/7] convert.c: stream and early out tboegi
@ 2016-03-29 13:25 ` tboegi
2016-03-29 13:25 ` [PATCH v1 4/7] t0027: TC for combined attributes tboegi
` (62 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-03-29 13:25 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Commit 942e77 "Add "core.eol" config variable" adds a condition to
the config parser: core.autocrlf=input is not allowed together with
core.eol=crlf.
This may lead to unnecessary problems, when config files are parsed:
A global config file sets core.autocrlf=input,
the repo local config file sets is own configuration: core.eol=crlf
There is no need to prevent combinations in config.c, in any case
core.autocrlf overrides core.eol.
Allow all combinations of core.crlf and core.eol and document
that core.autocrlf overrides core.eol.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 6 +++---
config.c | 4 ----
2 files changed, 3 insertions(+), 7 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 2cd6bdd..4a27ad4 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -337,9 +337,9 @@ core.quotePath::
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
+ files that have the `text` property set when core.autocrlf is false.
+ 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.
diff --git a/config.c b/config.c
index 9ba40bc..a6adc8b 100644
--- a/config.c
+++ b/config.c
@@ -803,8 +803,6 @@ static int git_default_core_config(const char *var, const char *value)
if (!strcmp(var, "core.autocrlf")) {
if (value && !strcasecmp(value, "input")) {
- if (core_eol == EOL_CRLF)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
auto_crlf = AUTO_CRLF_INPUT;
return 0;
}
@@ -830,8 +828,6 @@ static int git_default_core_config(const char *var, const char *value)
core_eol = EOL_NATIVE;
else
core_eol = EOL_UNSET;
- if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
return 0;
}
--
2.8.0.rc2.6.g3847ccb
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v1 4/7] t0027: TC for combined attributes
2016-03-07 22:34 ` Junio C Hamano
` (2 preceding siblings ...)
2016-03-29 13:25 ` [PATCH v1 3/7] Allow core.autocrlf=input and core.eol=crlf tboegi
@ 2016-03-29 13:25 ` tboegi
2016-03-29 13:25 ` [PATCH v1 5/7] CRLF: unify the "auto" handling tboegi
` (61 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-03-29 13:25 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Add more test cases for the not normalized files ("NNO").
The "text" attribute is most important, use it as the first parameter.
"ident", if set, is the second paramater followed by the eol attribute.
The eol attribute overrides core.autocrlf, which overrides core.eol.
Use loops to test more combinations of attributes, like
"* text eol=crlf" or especially "*text=auto eol=crlf".
Currently "* text=auto eol=lf" does the same as "* text eol=lf", as the
eol attribute overrides "text=auto", this will change in future.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t0027-auto-crlf.sh | 321 +++++++++++++++++++++++++--------------------------
1 file changed, 158 insertions(+), 163 deletions(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index f33962b..55f45d3 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -52,14 +52,17 @@ create_gitattributes () {
create_NNO_files () {
for crlf in false true input
do
- for attr in "" auto text -text lf crlf
+ for attr in "" auto text -text
do
- pfx=NNO_${crlf}_attr_${attr} &&
- cp CRLF_mix_LF ${pfx}_LF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
- cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ for aeol in "" lf crlf
+ do
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ cp CRLF_mix_LF ${pfx}_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ done
done
done
}
@@ -100,16 +103,17 @@ commit_check_warn () {
}
commit_chk_wrnNNO () {
- crlf=$1
- attr=$2
- lfwarn=$3
- crlfwarn=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfwarn=$1 ; shift
+ crlfwarn=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
#Commit files on top of existing file
- create_gitattributes "$attr" &&
+ create_gitattributes "$attr" $aeol &&
for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
do
fname=${pfx}_$f.txt &&
@@ -121,19 +125,19 @@ commit_chk_wrnNNO () {
test_expect_success "commit NNO files crlf=$crlf attr=$attr LF" '
check_warning "$lfwarn" ${pfx}_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF" '
check_warning "$crlfwarn" ${pfx}_CRLF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_mix_LF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_mix_LF" '
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr LF_mix_cr" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf LF_mix_cr" '
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_nul" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_nul" '
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
'
}
@@ -162,6 +166,7 @@ stats_ascii () {
# contruct the attr/ returned by git ls-files --eol
# Take none (=empty), one or two args
+# convert.c: eol=XX overrides text=auto
attr_ascii () {
case $1,$2 in
-text,*) echo "-text" ;;
@@ -169,8 +174,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text=auto eol=lf" ;;
- auto,crlf) echo "text=auto eol=crlf" ;;
+ auto,lf) echo "text eol=lf" ;;
+ auto,crlf) echo "text eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -195,28 +200,29 @@ check_files_in_repo () {
}
check_in_repo_NNO () {
- crlf=$1
- attr=$2
- lfname=$3
- crlfname=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}_
- test_expect_success "compare_files $lfname ${pfx}LF.txt" '
- compare_files $lfname ${pfx}LF.txt
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfname=$1 ; shift
+ crlfname=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ test_expect_success "compare_files $lfname ${pfx}_LF.txt" '
+ compare_files $lfname ${pfx}_LF.txt
'
- test_expect_success "compare_files $crlfname ${pfx}CRLF.txt" '
- compare_files $crlfname ${pfx}CRLF.txt
+ test_expect_success "compare_files $crlfname ${pfx}_CRLF.txt" '
+ compare_files $crlfname ${pfx}_CRLF.txt
'
- test_expect_success "compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt" '
- compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt
+ test_expect_success "compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt" '
+ compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt
'
- test_expect_success "compare_files $lfmixcr ${pfx}LF_mix_CR.txt" '
- compare_files $lfmixcr ${pfx}LF_mix_CR.txt
+ test_expect_success "compare_files $lfmixcr ${pfx}_LF_mix_CR.txt" '
+ compare_files $lfmixcr ${pfx}_LF_mix_CR.txt
'
- test_expect_success "compare_files $crlfnul ${pfx}CRLF_nul.txt" '
- compare_files $crlfnul ${pfx}CRLF_nul.txt
+ test_expect_success "compare_files $crlfnul ${pfx}_CRLF_nul.txt" '
+ compare_files $crlfnul ${pfx}_CRLF_nul.txt
'
}
@@ -231,7 +237,7 @@ checkout_files () {
lfmixcrlf=$1 ; shift
lfmixcr=$1 ; shift
crlfnul=$1 ; shift
- create_gitattributes "$attr" "$ident" &&
+ create_gitattributes "$attr" $ident $aeol &&
git config core.autocrlf $crlf &&
pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
@@ -244,7 +250,7 @@ checkout_files () {
fi
done
- test_expect_success "ls-files --eol attr=$attr $ident $aeol core.autocrlf=$crlf core.eol=$ceol" '
+ test_expect_success "ls-files --eol attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol" '
test_when_finished "rm expect actual" &&
sort <<-EOF >expect &&
i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
@@ -385,31 +391,31 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
-commit_chk_wrnNNO false "" "" "" "" "" ""
-commit_chk_wrnNNO true "" "LF_CRLF" "" "" "" ""
-commit_chk_wrnNNO input "" "" "" "" "" ""
-
+# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+commit_chk_wrnNNO "" "" false "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO false "auto" "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO true "auto" "LF_CRLF" "" "LF_CRLF" "" ""
-commit_chk_wrnNNO input "auto" "" "CRLF_LF" "CRLF_LF" "" ""
+commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-commit_chk_wrnNNO false "text" "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO true "text" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "text" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-
-commit_chk_wrnNNO false "-text" "" "" "" "" ""
-commit_chk_wrnNNO true "-text" "" "" "" "" ""
-commit_chk_wrnNNO input "-text" "" "" "" "" ""
-
-commit_chk_wrnNNO false "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO true "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO input "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
+for crlf in true false input;
+do
+ commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+done
-commit_chk_wrnNNO false "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO true "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
test_expect_success 'create files cleanup' '
rm -f *.txt &&
@@ -440,24 +446,20 @@ test_expect_success 'commit -text' '
check_files_in_repo input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
'
-# attr LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
-check_in_repo_NNO false "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "auto" LF LF LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO true "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO input "text" LF LF LF LF_mix_CR LF_nul
-
-check_in_repo_NNO false "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-
+for crlf in true false input;
+do
+ # attr aeol LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
+ check_in_repo_NNO "" "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+done
################################################################################
# Check how files in the repo are changed when they are checked out
# How to read the table below:
@@ -489,89 +491,82 @@ LFNUL=LF_nul
fi
export CRLF_MIX_LF_CR MIX NL
-checkout_files "" "" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true "" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true crlf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true lf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true native CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true "" CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true lf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true native CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-
+# Same handling with and without ident
for id in "" ident;
do
- checkout_files "crlf" "$id" "" false "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "lf" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "-text" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # -text overrides core.autocrlf and core.eol
+ # text and eol=crlf or eol=lf override core.autocrlf and core.eol
+ for crlf in true false input;
+ do
+ for ceol in "" lf crlf native;
+ do
+ checkout_files "-text" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "text" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+ done
+ # text: core.autocrlf=false uses core.eol
+ checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files "auto" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files "auto" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+
+ for ceol in "" lf crlf native;
+ do
+ # text: core.autocrlf = true overrides core.eol
+ checkout_files "text" "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # text: core.autocrlf = input overrides core.eol
+ checkout_files "text" "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ done
+ # No text attr
+ for ceol in "" lf crlf native;
+ do
+ # core.autocrlf!=true gives LF (or mixed) at checkout
+ for crlf in false input;
+ do
+ checkout_files "" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ done
+ done
+done
+
+#Handling without ident
+for id in "";
+do
+ for ceol in "" lf crlf native;
+ do
+ # core.autocrlf=true
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ # text=auto + eol=XXX
+ # currently the same as text, eol=XXX
+ checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+done
+
+#Handling with ident
+for id in ident;
+do
+ for crlf in "" true false input;
+ do
+ for ceol in "" lf crlf native;
+ do
+ # ident does not react on core.autocrlf=true
+ checkout_files "" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # ident does not react on text=auto
+ checkout_files "auto" "$id" "" true "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text=auto + eol=XXX
+ # currently the same as text, eol=XXX
+ checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+ done
done
# Should be the last test case: remove some files from the worktree
--
2.8.0.rc2.6.g3847ccb
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v1 5/7] CRLF: unify the "auto" handling
2016-03-07 22:34 ` Junio C Hamano
` (3 preceding siblings ...)
2016-03-29 13:25 ` [PATCH v1 4/7] t0027: TC for combined attributes tboegi
@ 2016-03-29 13:25 ` tboegi
2016-03-29 19:42 ` Eric Sunshine
2016-03-29 13:25 ` [PATCH v1 6/7] correct blame for files commited with CRLF tboegi
` (60 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-03-29 13:25 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Make .gitattributes "* text=auto eol=crlf" to do the same as
setting core.autocrlf=true and "* text=auto eol=crlf" the same
as core.autocrlf=input
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 11 +++++-----
Documentation/gitattributes.txt | 7 ++++---
convert.c | 37 ++++++++++++++++-----------------
t/t0025-crlf-auto.sh | 4 ++--
t/t0027-auto-crlf.sh | 45 +++++++++++++++++++----------------------
5 files changed, 52 insertions(+), 52 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 4a27ad4..3191a42 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -389,14 +389,15 @@ 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
+ Setting this variable to "true" is the same as setting
+ the attributes to "auto eol=crlf" on all files.
+ 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',
+ working directory and he repository has normalized line endings.
+ This variable can be set to 'input',
in which case no output conversion is performed.
+ Note: older versions of Git behave different.
core.symlinks::
If false, symbolic links are checked out as small plain files that
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index e3b1de8..43b70b5 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -115,6 +115,7 @@ 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.eol` configuration variable for all text files.
+Note that `core.autocrlf` overrides `core.eol`
Set::
@@ -187,8 +188,8 @@ regardless of their content.
------------------------
*.txt text
-*.vcproj eol=crlf
-*.sh eol=lf
+*.vcproj text eol=crlf
+*.sh text eol=lf
*.jpg -text
------------------------
@@ -198,7 +199,7 @@ 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.
+config variable "core.autocrlf" without using any attributes.
------------------------
[core]
diff --git a/convert.c b/convert.c
index b6da114..4ed5d89 100644
--- a/convert.c
+++ b/convert.c
@@ -229,7 +229,9 @@ static enum eol output_eol(enum crlf_action crlf_action)
return EOL_LF;
case CRLF_UNDEFINED:
case CRLF_AUTO_CRLF:
+ return EOL_CRLF;
case CRLF_AUTO_INPUT:
+ return EOL_LF;
case CRLF_TEXT:
case CRLF_AUTO:
/* fall through */
@@ -302,15 +304,12 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
-
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /*
- * 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 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, crlf_action, &stats, checksafe);
@@ -370,12 +369,10 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
- }
+ /* If we have any CR or CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (stats.lonecr || stats.crlf )
+ return 0;
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
@@ -836,7 +833,11 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
ca->drv = git_path_check_convert(ccheck + 2);
if (ca->crlf_action != CRLF_BINARY) {
enum eol eol_attr = git_path_check_eol(ccheck + 3);
- if (eol_attr == EOL_LF)
+ if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_LF)
+ ca->crlf_action = CRLF_AUTO_INPUT;
+ else if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_CRLF)
+ ca->crlf_action = CRLF_AUTO_CRLF;
+ else if (eol_attr == EOL_LF)
ca->crlf_action = CRLF_TEXT_INPUT;
else if (eol_attr == EOL_CRLF)
ca->crlf_action = CRLF_TEXT_CRLF;
@@ -895,9 +896,9 @@ const char *get_convert_attr_ascii(const char *path)
case CRLF_AUTO:
return "text=auto";
case CRLF_AUTO_CRLF:
- return "text=auto eol=crlf"; /* This is not supported yet */
+ return "text=auto eol=crlf";
case CRLF_AUTO_INPUT:
- return "text=auto eol=lf"; /* This is not supported yet */
+ return "text=auto eol=lf";
}
return "";
}
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index c164b46..d0bee08 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -114,7 +114,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
+test_expect_success 'text=auto, autocrlf=true does not normalize CRLF files' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
git config core.autocrlf true &&
@@ -126,7 +126,7 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
LFonlydiff=$(git diff LFonly) &&
CRLFonlydiff=$(git diff CRLFonly) &&
LFwithNULdiff=$(git diff LFwithNUL) &&
- test -z "$LFonlydiff" -a -n "$CRLFonlydiff" -a -z "$LFwithNULdiff"
+ test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 55f45d3..86175cf 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -174,8 +174,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text eol=lf" ;;
- auto,crlf) echo "text eol=crlf" ;;
+ auto,lf) echo "text=auto eol=lf" ;;
+ auto,crlf) echo "text=auto eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -396,10 +396,9 @@ commit_chk_wrnNNO "" "" false "" "" "" ""
commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
-commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-
+commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input;
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
@@ -407,8 +406,8 @@ do
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
done
@@ -453,9 +452,9 @@ do
check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
@@ -513,8 +512,6 @@ do
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "auto" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "auto" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
for ceol in "" lf crlf native;
do
@@ -541,30 +538,30 @@ do
for ceol in "" lf crlf native;
do
# core.autocrlf=true
- checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "auto" "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text=auto + eol=XXX
- # currently the same as text, eol=XXX
- checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
done
#Handling with ident
for id in ident;
do
- for crlf in "" true false input;
+ for crlf in true false input;
do
for ceol in "" lf crlf native;
do
# ident does not react on core.autocrlf=true
- checkout_files "" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# ident does not react on text=auto
- checkout_files "auto" "$id" "" true "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" true "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text=auto + eol=XXX
- # currently the same as text, eol=XXX
- checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
done
done
--
2.8.0.rc2.6.g3847ccb
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v1 6/7] correct blame for files commited with CRLF
2016-03-07 22:34 ` Junio C Hamano
` (4 preceding siblings ...)
2016-03-29 13:25 ` [PATCH v1 5/7] CRLF: unify the "auto" handling tboegi
@ 2016-03-29 13:25 ` tboegi
2016-03-29 17:21 ` Junio C Hamano
2016-03-29 13:25 ` [PATCH v1 7/7] convert.c: more safer crlf handling with text attribute tboegi
` (59 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-03-29 13:25 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
git blame reports lines as not "Not Committed Yet" when they have
CRLF in the index, CRLF in the worktree and e.g. core.autocrlf is true.
Since commit c48053 "new safer autocrlf handling", files that have CRLF
in the index are not normalized at commit when e.g. core.autocrl is set.
Whenever a CLRF conversion is needed (or any filter us set), load the
index temporally, before calling convert_to_git()
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
builtin/blame.c | 6 +++++-
convert.c | 10 ++++++++++
convert.h | 1 +
t/t8003-blame-corner-cases.sh | 14 ++++++++++++++
4 files changed, 30 insertions(+), 1 deletion(-)
diff --git a/builtin/blame.c b/builtin/blame.c
index e982fb8..a219068 100644
--- a/builtin/blame.c
+++ b/builtin/blame.c
@@ -2376,7 +2376,11 @@ static struct commit *fake_working_tree_commit(struct diff_options *opt,
if (strbuf_read(&buf, 0, 0) < 0)
die_errno("failed to read from stdin");
}
- convert_to_git(path, buf.buf, buf.len, &buf, 0);
+ if (convert_needs_conversion(path)) {
+ read_cache();
+ convert_to_git(path, buf.buf, buf.len, &buf, 0);
+ discard_cache();
+ }
origin->file.ptr = buf.buf;
origin->file.size = buf.len;
pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_sha1);
diff --git a/convert.c b/convert.c
index 4ed5d89..02c50da 100644
--- a/convert.c
+++ b/convert.c
@@ -903,6 +903,16 @@ const char *get_convert_attr_ascii(const char *path)
return "";
}
+int convert_needs_conversion(const char *path)
+{
+ struct conv_attrs ca;
+
+ convert_attrs(&ca, path);
+ if (ca.drv || ca.ident || ca.crlf_action != CRLF_BINARY)
+ return 1;
+ return 0;
+}
+
int convert_to_git(const char *path, const char *src, size_t len,
struct strbuf *dst, enum safe_crlf checksafe)
{
diff --git a/convert.h b/convert.h
index ccf436b..ffd9c32 100644
--- a/convert.h
+++ b/convert.h
@@ -35,6 +35,7 @@ extern enum eol core_eol;
extern const char *get_cached_convert_stats_ascii(const char *path);
extern const char *get_wt_convert_stats_ascii(const char *path);
extern const char *get_convert_attr_ascii(const char *path);
+int convert_needs_conversion(const char *path);
/* returns 1 if *dst was used */
extern int convert_to_git(const char *path, const char *src, size_t len,
diff --git a/t/t8003-blame-corner-cases.sh b/t/t8003-blame-corner-cases.sh
index 6568429..a9b266f 100755
--- a/t/t8003-blame-corner-cases.sh
+++ b/t/t8003-blame-corner-cases.sh
@@ -212,4 +212,18 @@ test_expect_success 'blame file with CRLF attributes text' '
grep "A U Thor" actual
'
+test_expect_success 'blame file with CRLF core.autocrlf=true' '
+ git config core.autocrlf false &&
+ printf "testcase\r\n" >crlfinrepo &&
+ >.gitattributes &&
+ git add crlfinrepo &&
+ git commit -m "add crlfinrepo" &&
+ git config core.autocrlf true &&
+ mv crlfinrepo tmp &&
+ git checkout crlfinrepo &&
+ rm tmp &&
+ git blame crlfinrepo >actual &&
+ grep "A U Thor" actual
+'
+
test_done
--
2.8.0.rc2.6.g3847ccb
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v1 7/7] convert.c: more safer crlf handling with text attribute
2016-03-07 22:34 ` Junio C Hamano
` (5 preceding siblings ...)
2016-03-29 13:25 ` [PATCH v1 6/7] correct blame for files commited with CRLF tboegi
@ 2016-03-29 13:25 ` tboegi
2016-03-29 18:37 ` Junio C Hamano
2016-04-01 16:08 ` [PATCH v2 1/7] Make it possible to get sha1 for a path from the index tboegi
` (58 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-03-29 13:25 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
A follow-up after a discussion how to fix the flaky execution
of t0025, gmane/$284352.
This patch extends the work done in commit c480539:
"Make it work also for un-normalized repositories". Make sure that CRLF
can be converted round trip, or don't convert them at all.
The old handling would treat a file as unchanged after checkout,
as long as it is not touched in the work tree and mtime matches the value
recorded in the index.
When the mtime is changed in the working tree, or the inode is changed,
the file is reported as modified.
The following sequence is now handled reproducable:
$ git init
$ printf "line1\r\n" >file.bat
$ git add file.bat
$ git commit -m "Add file with CRLF" file.bat
$ echo "*.bat text eol=crlf" >.gitattributes
$ git commit -m "bat files should have CRLF"
$ git status
# nothing to commit, working directory clean
$ git push <upstream>
$ printf "newline\r\n" >>file.bat
$ mv file.bat file.sav
$ git checkout file.bat
$ git status
#modified: file.bat
The new handling makes sure that after running "git reset --hard".
"git status" reports the working tree as clean regarding CRLF conversion.
It makes sure that the Git-internal eol conversion is
doing roundtrip. A user can still write an external smudge/clean filter
outside Git, which doesn't do a roundtrip and the working directory is
not clean.
The functionality of has_cr_in_index() is turned into has_crlf_in_index(),
and the function is integrated into would_convert_crlf_at_commit().
Check for CRLF in the index instead of CR, the bit CONVERT_STAT_BITS_ANY_CR
is no longer used and removed, as well as "lonecr" in struct text_stat.
Rewrite check_safe_crlf() in convert.c to simulate checkin-checkout,
to detect whether any line endings are converted.
Modify the lf_to_crlf_filter:
Files with LF are converted into CRLF, file with CRLF are not changed.
Files with mixed line endings are not converted, the filter fails, and Git
falls back to the non-streaming handling, see write_entry().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/gitattributes.txt | 10 +-
convert.c | 215 ++++++++++++++++++++++++----------------
t/t0025-crlf-auto.sh | 8 +-
t/t0027-auto-crlf.sh | 38 +++----
4 files changed, 158 insertions(+), 113 deletions(-)
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index 43b70b5..7929880 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -110,7 +110,7 @@ repository upon 'git add' and 'git commit'.
`text`
^^^^^^
-This attribute enables and controls end-of-line normalization. When a
+This attribute enables and controls end-of-line conversion. 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
@@ -120,8 +120,11 @@ Note that `core.autocrlf` overrides `core.eol`
Set::
Setting the `text` attribute on a path enables end-of-line
- normalization and marks the path as a text file. End-of-line
+ conversion and marks the path as a text file. End-of-line
conversion takes place without guessing the content type.
+ Files that have been commited with CRLF before the text attribute
+ is set and commited are not normalized. No end-of-line conversion
+ is done at checkout or checkin.
Unset::
@@ -132,7 +135,8 @@ Set to string value "auto"::
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.
+ text, and the path has no CRLF in the index,
+ its line endings are converted to LF on checkin.
Unspecified::
diff --git a/convert.c b/convert.c
index 02c50da..8266d87 100644
--- a/convert.c
+++ b/convert.c
@@ -17,7 +17,6 @@
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
-#define CONVERT_STAT_BITS_ANY_CR 0x8
enum crlf_action {
CRLF_UNDEFINED,
@@ -32,7 +31,7 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned stat_bits, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonelf;
/* These are just approximations! */
unsigned printable, nonprintable;
@@ -48,13 +47,10 @@ static void do_gather_stats(const char *buf, unsigned long size,
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
- stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
- stats->crlf++;
i++;
stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
} else {
- stats->lonecr++;
stats->stat_bits |= CONVERT_STAT_BITS_BIN;
}
continue;
@@ -136,7 +132,7 @@ static unsigned get_convert_stats_sha1(const char *path,
if (!readlen)
break;
do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
- if (stats.stat_bits & earlyout)
+ if ((stats.stat_bits & earlyout) == earlyout)
break; /* We found what we have been searching for */
}
close_and_exit_i:
@@ -147,11 +143,9 @@ close_and_exit_i:
static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned mask = CONVERT_STAT_BITS_TXT_LF |
- CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats & mask) {
+ switch (convert_stats) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -163,7 +157,17 @@ static const char *convert_stats_ascii(unsigned convert_stats)
}
}
-static unsigned get_convert_stats_wt(const char *path)
+const char *get_cached_convert_stats_ascii(const char *path)
+{
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(path,
+ get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
+}
+
+const char *get_wt_convert_stats_ascii(const char *path)
{
struct text_stat stats;
unsigned earlyout = CONVERT_STAT_BITS_BIN;
@@ -185,24 +189,7 @@ static unsigned get_convert_stats_wt(const char *path)
}
close(fd);
convert_nonprintable(&stats);
- return stats.stat_bits;
-}
-
-const char *get_cached_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- unsigned earlyout = CONVERT_STAT_BITS_BIN;
- convert_stats = get_convert_stats_sha1(path,
- get_sha1_from_cache(path),
- earlyout);
- return convert_stats_ascii(convert_stats);
-}
-
-const char *get_wt_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_wt(path);
- return convert_stats_ascii(convert_stats);
+ return convert_stats_ascii(stats.stat_bits);
}
static int text_eol_is_crlf(void)
@@ -241,53 +228,90 @@ static enum eol output_eol(enum crlf_action crlf_action)
return core_eol;
}
+static int would_convert_lf_at_checkout(unsigned convert_stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ if (output_eol(crlf_action) != EOL_CRLF)
+ return 0;
+
+ /* No "naked" LF? Nothing to convert, regardless. */
+ if (!convert_stats & CONVERT_STAT_BITS_TXT_LF)
+ return 0;
+
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ /* auto: binary files are not converted */
+ if (convert_stats & CONVERT_STAT_BITS_BIN)
+ return 0;
+ }
+ /* If we have any CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+
+}
+
+static int would_convert_crlf_at_commit(const char * path,
+ const struct text_stat *stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ unsigned stat_bits_index;
+ /* No CRLF? Nothing to convert, regardless. */
+ if (!(stats->stat_bits & CONVERT_STAT_BITS_TXT_CRLF))
+ return 0;
+ /*
+ * If the file in the index has any CRLF in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ stat_bits_index = get_convert_stats_sha1(path,
+ get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_TXT_CRLF);
+ if (stat_bits_index & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+}
+
static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
- struct text_stat *stats, enum safe_crlf checksafe)
+ enum safe_crlf checksafe,
+ unsigned convert_stats, unsigned new_convert_stats)
{
if (!checksafe)
return;
-
- if (output_eol(crlf_action) == EOL_LF) {
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
/*
* 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.\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 (output_eol(crlf_action) == EOL_CRLF) {
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if (convert_stats & CONVERT_STAT_BITS_TXT_LF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_LF)) {
/*
* CRLFs would be added by checkout:
* check if we have "naked" LFs
*/
- if (stats->lonelf) {
- if (checksafe == SAFE_CRLF_WARN)
- 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);
- }
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
}
}
-static int has_cr_in_index(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_sha1(path,
- get_sha1_from_cache(path),
- CONVERT_STAT_BITS_ANY_CR);
- return convert_stats & CONVERT_STAT_BITS_ANY_CR;
-}
-
static int crlf_to_git(const char *path, const char *src, size_t len,
struct strbuf *buf,
enum crlf_action crlf_action, enum safe_crlf checksafe)
{
struct text_stat stats;
char *dst;
-
+ int convert_crlf;
if (crlf_action == CRLF_BINARY ||
(src && !len))
return 0;
@@ -299,23 +323,36 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
-
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
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;
+ } else {
+ gather_stats(src, len, &stats, 0);
}
-
- check_safe_crlf(path, crlf_action, &stats, checksafe);
-
- /* Optimization: No CRLF? Nothing to convert, regardless. */
- if (!stats.crlf)
+ convert_crlf = would_convert_crlf_at_commit(path, &stats, len,
+ crlf_action);
+ if (checksafe) {
+ unsigned convert_stats = stats.stat_bits;
+ unsigned new_convert_stats = convert_stats;
+ /* Simulate commit */
+ if (convert_crlf &&
+ (new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_LF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_CRLF;
+ }
+ /* Simulate checkout */
+ if (would_convert_lf_at_checkout(new_convert_stats,
+ len, crlf_action)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_CRLF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_LF;
+ }
+ check_safe_crlf(path, crlf_action, checksafe,
+ convert_stats, new_convert_stats);
+ }
+ if (!convert_crlf)
return 0;
/*
@@ -329,7 +366,9 @@ 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 (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
/*
* If we guessed, we already know we rejected a file with
* lone CR, and we can strip a CR without looking at what
@@ -356,28 +395,15 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
- unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
-
-
- if (!len || output_eol(crlf_action) != EOL_CRLF)
+ unsigned earlyout = 0; /* Need to count lonelf */
+ if (!len)
return 0;
gather_stats(src, len, &stats, earlyout);
-
- /* No "naked" LF? Nothing to convert, regardless. */
- if (!stats.lonelf)
+ if (!would_convert_lf_at_checkout(stats.stat_bits,
+ len, crlf_action))
return 0;
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
-
- if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
- return 0;
- }
-
/* are we "faking" in place editing ? */
if (src == buf->buf)
to_free = strbuf_detach(buf, NULL);
@@ -1079,6 +1105,8 @@ int is_null_stream_filter(struct stream_filter *filter)
struct lf_to_crlf_filter {
struct stream_filter filter;
unsigned has_held:1;
+ unsigned expanded_loneLF:1;
+ unsigned had_CRLF:1;
char held;
};
@@ -1119,7 +1147,12 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
char ch = input[i];
if (ch == '\n') {
- output[o++] = '\r';
+ if (!lf_to_crlf->had_CRLF) {
+ output[o++] = '\r';
+ lf_to_crlf->expanded_loneLF = 1;
+ }
+ if (was_cr)
+ lf_to_crlf->had_CRLF = 1;
} else if (was_cr) {
/*
* Previous round saw CR and it is not followed
@@ -1148,6 +1181,14 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
was_cr = 0;
output[o++] = ch;
+ if (lf_to_crlf->expanded_loneLF &&
+ lf_to_crlf->had_CRLF) {
+ /*
+ * Mixed EOL, round trip not possible.
+ */
+ return 1;
+ }
+
}
*osize_p -= o;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index d0bee08..b5f93e2 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 "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'crlf=true causes a CRLF file to be normalized' '
+test_expect_success 'crlf=true causes a CRLF file not to be normalized' '
# Backwards compatibility check
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
@@ -49,10 +49,10 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
-test_expect_success 'text=true causes a CRLF file to be normalized' '
+test_expect_success 'text=true causes a CRLF file not to be normalized' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
echo "CRLFonly text" > .gitattributes &&
@@ -61,7 +61,7 @@ test_expect_success 'text=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 86175cf..3fa9be4 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -354,7 +354,7 @@ else
WAMIX=CRLF_LF
fi
-# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
+# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
test_expect_success 'commit files empty attr' '
commit_check_warn false "" "" "" "" "" "" &&
commit_check_warn true "" "LF_CRLF" "" "LF_CRLF" "" "" &&
@@ -391,7 +391,7 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
commit_chk_wrnNNO "" "" false "" "" "" "" ""
commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
commit_chk_wrnNNO "" "" input "" "" "" "" ""
@@ -401,20 +401,22 @@ commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" ""
commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input;
do
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
- commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO "" lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" "" LF_CRLF ""
commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
- commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO text lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" "" LF_CRLF ""
done
-commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
-commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+commit_chk_wrnNNO "text" "" false "$WILC" "" "" "$WILC" ""
+commit_chk_wrnNNO "text" "" true LF_CRLF "" "" LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" "" "" "" ""
test_expect_success 'create files cleanup' '
rm -f *.txt &&
@@ -455,9 +457,9 @@ do
check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
done
################################################################################
# Check how files in the repo are changed when they are checked out
@@ -478,12 +480,10 @@ done
if test_have_prereq NATIVE_CRLF
then
-MIX_CRLF_LF=CRLF
MIX_LF_CR=CRLF_mix_CR
NL=CRLF
LFNUL=CRLF_nul
else
-MIX_CRLF_LF=CRLF_mix_LF
MIX_LF_CR=LF_mix_CR
NL=LF
LFNUL=LF_nul
@@ -503,20 +503,20 @@ do
checkout_files "-text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "-text" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "text" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
done
done
# text: core.autocrlf=false uses core.eol
- checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files "text" "$id" "" false "" $NL CRLF CRLF_mix_LF $MIX_LF_CR $LFNUL
+ checkout_files "text" "$id" "" false native $NL CRLF CRLF_mix_LF $MIX_LF_CR $LFNUL
for ceol in "" lf crlf native;
do
# text: core.autocrlf = true overrides core.eol
- checkout_files "text" "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "text" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
checkout_files "text" "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "auto" "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
--
2.8.0.rc2.6.g3847ccb
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH v1 1/7] Make it possible to get sha1 for a path from the index
2016-03-29 13:25 ` [PATCH v1 1/7] Make it possible to get sha1 for a path from the index tboegi
@ 2016-03-29 13:28 ` Duy Nguyen
2016-03-29 13:31 ` Duy Nguyen
2016-03-29 19:32 ` Eric Sunshine
1 sibling, 1 reply; 126+ messages in thread
From: Duy Nguyen @ 2016-03-29 13:28 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: Git Mailing List
On Tue, Mar 29, 2016 at 8:25 PM, <tboegi@web.de> wrote:
> From: Torsten Bögershausen <tboegi@web.de>
>
> Factor out the retrival of the sha1 for a given path in
> read_blob_data_from_index() into the function get_sha1_from_index().
Getting _sha1_ from index is one function call and a memory
dereference or two. I think you mean get sha1 _file_ (or data) from
index. Maybe put either word in the function name.
> This will be used in the next commit, when convert.c can do the analyze
> for "text=auto" without slurping the whole blob into memory at once.
--
Duy
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 1/7] Make it possible to get sha1 for a path from the index
2016-03-29 13:28 ` Duy Nguyen
@ 2016-03-29 13:31 ` Duy Nguyen
2016-03-29 15:05 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Duy Nguyen @ 2016-03-29 13:31 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: Git Mailing List
On Tue, Mar 29, 2016 at 8:28 PM, Duy Nguyen <pclouds@gmail.com> wrote:
> On Tue, Mar 29, 2016 at 8:25 PM, <tboegi@web.de> wrote:
>> From: Torsten Bögershausen <tboegi@web.de>
>>
>> Factor out the retrival of the sha1 for a given path in
>> read_blob_data_from_index() into the function get_sha1_from_index().
>
> Getting _sha1_ from index is one function call and a memory
> dereference or two. I think you mean get sha1 _file_ (or data) from
> index. Maybe put either word in the function name.
Oops, shouldn't have trusted that function name in the @@ line. No
what you write in the commit message matches the patch. Sorry for the
noise.
--
Duy
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 1/7] Make it possible to get sha1 for a path from the index
2016-03-29 13:31 ` Duy Nguyen
@ 2016-03-29 15:05 ` Torsten Bögershausen
0 siblings, 0 replies; 126+ messages in thread
From: Torsten Bögershausen @ 2016-03-29 15:05 UTC (permalink / raw)
To: Duy Nguyen, Torsten Bögershausen; +Cc: Git Mailing List
On 2016-03-29 15.31, Duy Nguyen wrote:
> On Tue, Mar 29, 2016 at 8:28 PM, Duy Nguyen <pclouds@gmail.com> wrote:
>> On Tue, Mar 29, 2016 at 8:25 PM, <tboegi@web.de> wrote:
>>> From: Torsten Bögershausen <tboegi@web.de>
>>>
>>> Factor out the retrival of the sha1 for a given path in
>>> read_blob_data_from_index() into the function get_sha1_from_index().
>>
>> Getting _sha1_ from index is one function call and a memory
>> dereference or two. I think you mean get sha1 _file_ (or data) from
>> index. Maybe put either word in the function name.
>
> Oops, shouldn't have trusted that function name in the @@ line. No
> what you write in the commit message matches the patch. Sorry for the
> noise.
>
Thanks for the review.
It feels that the naming isn't ideal, let's see if we can find a better
function name.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 6/7] correct blame for files commited with CRLF
2016-03-29 13:25 ` [PATCH v1 6/7] correct blame for files commited with CRLF tboegi
@ 2016-03-29 17:21 ` Junio C Hamano
2016-03-29 19:51 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-03-29 17:21 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> git blame reports lines as not "Not Committed Yet" when they have
> CRLF in the index, CRLF in the worktree and e.g. core.autocrlf is true.
>
> Since commit c48053 "new safer autocrlf handling", files that have CRLF
> in the index are not normalized at commit when e.g. core.autocrl is set.
>
> Whenever a CLRF conversion is needed (or any filter us set), load the
> index temporally, before calling convert_to_git()
Sorry, but I do not understand what problem you are trying to
address here.
Under the same condition described in the first paragraph, what
would "git diff" and "git diff HEAD" say? They should show that you
would be making a commit that corrects the line ending of the blob
recorded in the history.
The "Not Committed Yet" output from "git blame" is the same thing.
It is telling you that the commit you would be making by adding
that path from the working tree in its current state will become
the one that is responsible for the final state of the line.
So it is absolutely the right thing that these lines are shown as
"Not Commited Yet". You will be making the line-ending correction
for the entire blob, and you should be made aware of it.
Now, it would be a very good idea for such a correction change to
have no other change, and it would be a very good idea to give users
a tool to see if there is any change other than the eol correction.
There is "git blame -w" to ignore whitespace changes, and I think
that would hide the CRLF/LF correction, but that hides all other kinds
of whitespace changes, so it is too broad for the purpose.
I do not think I'd be opposed to a new option to allow the command
to ignore _only_ eol changes (this applies not just to "blame" but
also to "diff", too). That way:
* The users can more easily make sure that the set of changes being
prepared does not do anything other than correcting eol;
* "git blame" can be told to relieve a commit of the responsibility
for lines if the only change it did to them is to correct eol
when digging the history (i.e. this will not just help "Not
Committed Yet" changes in the working tree, but for digging
through historical events).
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 7/7] convert.c: more safer crlf handling with text attribute
2016-03-29 13:25 ` [PATCH v1 7/7] convert.c: more safer crlf handling with text attribute tboegi
@ 2016-03-29 18:37 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-03-29 18:37 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> A follow-up after a discussion how to fix the flaky execution
> of t0025, gmane/$284352.
> ...
> The new handling makes sure that after running "git reset --hard".
> "git status" reports the working tree as clean regarding CRLF
> conversion. It makes sure that the Git-internal eol conversion is
> doing roundtrip. A user can still write an external smudge/clean
> filter outside Git, which doesn't do a roundtrip and the working
> directory is not clean.
If the project (not Git itself, but I am talking about any project
used by real people) declares that the blobs in the history must be
using LF endings (perhaps it wants to be protable across two worlds)
by telling the users to set configurations so that "git add" would
do the crlf-to-lf conversion, why is it a good idea to bend over
backwards to _hide_ the fact that the index records something that
contradicts with the project policy expressed by the end-user
configuration? If the project wants to standardize on CRLF endings
in the recorded history and some users use configurations and filters
to use LF ending in their working tree, the same argument applies.
If they by mistake or whatever adds blobs with LF line ending, that
also should be shown as a change.
I would understand if the "fix" were to make sure that the working
tree files are dirty after "git reset --hard". If you "git add" the
files from the working tree and make a commit from such a state, you
will be changing the path in the commited history, so by definition
the working tree should be reported as dirty, shouldn't it?
I started to suspect that the flaky test in t0025 is not worth
addressing for some time ago (iow, it is testing and expecting some
fixed result where we should just declare "the behaviour is
undefined if you did so"), and especially if the best we can do is
to treat line-ending conversion something so special, it does not
sound like we are going in the right direction.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 1/7] Make it possible to get sha1 for a path from the index
2016-03-29 13:25 ` [PATCH v1 1/7] Make it possible to get sha1 for a path from the index tboegi
2016-03-29 13:28 ` Duy Nguyen
@ 2016-03-29 19:32 ` Eric Sunshine
1 sibling, 0 replies; 126+ messages in thread
From: Eric Sunshine @ 2016-03-29 19:32 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: Git List
On Tue, Mar 29, 2016 at 9:25 AM, <tboegi@web.de> wrote:
> Factor out the retrival of the sha1 for a given path in
s/retrival/retrieval/
> read_blob_data_from_index() into the function get_sha1_from_index().
>
> This will be used in the next commit, when convert.c can do the analyze
> for "text=auto" without slurping the whole blob into memory at once.
>
> Add a wrapper definition get_sha1_from_cache().
>
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 5/7] CRLF: unify the "auto" handling
2016-03-29 13:25 ` [PATCH v1 5/7] CRLF: unify the "auto" handling tboegi
@ 2016-03-29 19:42 ` Eric Sunshine
0 siblings, 0 replies; 126+ messages in thread
From: Eric Sunshine @ 2016-03-29 19:42 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: Git List
On Tue, Mar 29, 2016 at 9:25 AM, <tboegi@web.de> wrote:
> Make .gitattributes "* text=auto eol=crlf" to do the same as
> setting core.autocrlf=true and "* text=auto eol=crlf" the same
> as core.autocrlf=input
>
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
> ---
> diff --git a/Documentation/config.txt b/Documentation/config.txt
> @@ -389,14 +389,15 @@ file with mixed line endings would be reported by the `core.safecrlf`
> 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
> + Setting this variable to "true" is the same as setting
> + the attributes to "auto eol=crlf" on all files.
> + 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',
> + working directory and he repository has normalized line endings.
s/he/the/
> + This variable can be set to 'input',
> in which case no output conversion is performed.
> + Note: older versions of Git behave different.
Would it make sense to spell out what "different" means since new
readers won't know what the old behavior was?
> diff --git a/convert.c b/convert.c
> @@ -370,12 +369,10 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
> if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
> - if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
> - /* If we have any CR or CRLF line endings, we do not touch it */
> - /* This is the new safer autocrlf-handling */
> - if (stats.lonecr || stats.crlf )
> - return 0;
> - }
> + /* If we have any CR or CRLF line endings, we do not touch it */
> + /* This is the new safer autocrlf-handling */
The comment style violation could have been fixed while outdenting,
but perhaps it's not worth the churn.
> + if (stats.lonecr || stats.crlf )
> + return 0;
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 6/7] correct blame for files commited with CRLF
2016-03-29 17:21 ` Junio C Hamano
@ 2016-03-29 19:51 ` Torsten Bögershausen
2016-03-29 19:58 ` Junio C Hamano
2016-03-29 20:25 ` Junio C Hamano
0 siblings, 2 replies; 126+ messages in thread
From: Torsten Bögershausen @ 2016-03-29 19:51 UTC (permalink / raw)
To: Junio C Hamano, tboegi; +Cc: git
On 29.03.16 19:21, Junio C Hamano wrote:
> tboegi@web.de writes:
>
>> From: Torsten Bögershausen <tboegi@web.de>
>>
>> git blame reports lines as not "Not Committed Yet" when they have
>> CRLF in the index, CRLF in the worktree and e.g. core.autocrlf is true.
>>
>> Since commit c48053 "new safer autocrlf handling", files that have CRLF
>> in the index are not normalized at commit when e.g. core.autocrl is set.
>>
>> Whenever a CLRF conversion is needed (or any filter us set), load the
>> index temporally, before calling convert_to_git()
>
> Sorry, but I do not understand what problem you are trying to
> address here.
>
> Under the same condition described in the first paragraph, what
> would "git diff" and "git diff HEAD" say? They should show that you
> would be making a commit that corrects the line ending of the blob
> recorded in the history.
>
Let's make an experiment, Git v2.8.0
$ printf "Line1\r\nLine2\r\n" >test_CRLF.txt
$ git add test_CRLF.txt
$ git commit -m "add test_CRLF.txt"
[detached HEAD 719c166] add test_CRLF.txt
1 file changed, 2 insertions(+)
create mode 100644 test_CRLF.txt
$ git ls-files --eol test_CRLF.txt
i/crlf w/crlf attr/ test_CRLF.txt
# So far, so good.
git config core.autocrlf true
# Now lets patch Git to debug the safer CRLF handling
diff --git a/convert.c b/convert.c
index f524b8d..fcf7653 100644
--- a/convert.c
+++ b/convert.c
@@ -260,8 +260,11 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
* 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))
+ if (has_cr_in_index(path)) {
+ fprintf(stderr, "%s/%s:%d has_cr_in_index(%s)\n",
+ __FILE__, __FUNCTION__, __LINE__, path);
return 0;
+ }
# Of course, run make
$ make
#
printf "Line3\r\n" >>test_CRLF.txt
# Lets see what diff says:
./git diff test_CRLF.txt | od -c
convert.c/crlf_to_git:265 has_cr_in_index(test_CRLF.txt)
convert.c/crlf_to_git:265 has_cr_in_index(test_CRLF.txt)
0000000 d i f f - - g i t a / t e s
0000020 t _ C R L F . t x t b / t e s
0000040 t _ C R L F . t x t \n i n d e x
0000060 4 a a 5 5 1 d . . d 0 f a f 1
0000100 d 1 0 0 6 4 4 \n - - - a / t
0000120 e s t _ C R L F . t x t \n + + +
0000140 b / t e s t _ C R L F . t x t
0000160 \n @ @ - 1 , 2 + 1 , 3 @ @
0000200 \n L i n e 1 \r \n L i n e 2 \r
0000220 \n + l i n e 3 \r \n
0000231
# Here the lines are not going to be normalized at the next commit.
# They stay CRLF.
# But git blame doesn't know that, because has_cr_in_index doesn't work
# without an index.
$ ./git blame test_CRLF.txt
00000000 (Not Committed Yet 2016-03-29 21:44:48 +0200 1) Line1
00000000 (Not Committed Yet 2016-03-29 21:44:48 +0200 2) Line2
00000000 (Not Committed Yet 2016-03-29 21:44:48 +0200 3) line3
$ git commit -m "Add line3" test_CRLF.txt
> The "Not Committed Yet" output from "git blame" is the same thing.
> It is telling you that the commit you would be making by adding
> that path from the working tree in its current state will become
> the one that is responsible for the final state of the line.
>
> So it is absolutely the right thing that these lines are shown as
> "Not Commited Yet". You will be making the line-ending correction
> for the entire blob, and you should be made aware of it.
If we had made the CRLF -> LF conversion, yes. But we don't do that.
crlf_to_git() returns without touching the line endings.
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH v1 6/7] correct blame for files commited with CRLF
2016-03-29 19:51 ` Torsten Bögershausen
@ 2016-03-29 19:58 ` Junio C Hamano
2016-03-29 20:25 ` Junio C Hamano
1 sibling, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-03-29 19:58 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
> # Here the lines are not going to be normalized at the next commit.
> # They stay CRLF.
Isn't that the real source of the problem? Why don't we fix that
then?
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 6/7] correct blame for files commited with CRLF
2016-03-29 19:51 ` Torsten Bögershausen
2016-03-29 19:58 ` Junio C Hamano
@ 2016-03-29 20:25 ` Junio C Hamano
2016-03-29 20:32 ` Junio C Hamano
1 sibling, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-03-29 20:25 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
> If we had made the CRLF -> LF conversion, yes. But we don't do that.
> crlf_to_git() returns without touching the line endings.
That sounds quite broken. How would a user ever fix broken data in
the index then? I know the commit that often appears in these
discussions claims to give us "safer CRLF" handling, but I have a
suspicion that perhaps we should rethink if that claim is really
true. Isn't it giving us more problems than it is worth?
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 6/7] correct blame for files commited with CRLF
2016-03-29 20:25 ` Junio C Hamano
@ 2016-03-29 20:32 ` Junio C Hamano
2016-03-29 20:50 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-03-29 20:32 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Junio C Hamano <gitster@pobox.com> writes:
> Torsten Bögershausen <tboegi@web.de> writes:
>
>> If we had made the CRLF -> LF conversion, yes. But we don't do that.
>> crlf_to_git() returns without touching the line endings.
>
> That sounds quite broken. How would a user ever fix broken data in
> the index then? I know the commit that often appears in these
> discussions claims to give us "safer CRLF" handling, but I have a
> suspicion that perhaps we should rethink if that claim is really
> true. Isn't it giving us more problems than it is worth?
Having said all that, within the context of the current codebase
where autocrlf refuses to do the conversion, I agree that teaching
blame to follow the same logic makes sense. Let me review the
series up to 6/7 with fresh eyes.
Thanks.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 6/7] correct blame for files commited with CRLF
2016-03-29 20:32 ` Junio C Hamano
@ 2016-03-29 20:50 ` Junio C Hamano
2016-03-30 17:48 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-03-29 20:50 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Junio C Hamano <gitster@pobox.com> writes:
> Junio C Hamano <gitster@pobox.com> writes:
>
>> Torsten Bögershausen <tboegi@web.de> writes:
>>
>>> If we had made the CRLF -> LF conversion, yes. But we don't do that.
>>> crlf_to_git() returns without touching the line endings.
>>
>> That sounds quite broken. How would a user ever fix broken data in
>> the index then? I know the commit that often appears in these
>> discussions claims to give us "safer CRLF" handling, but I have a
>> suspicion that perhaps we should rethink if that claim is really
>> true. Isn't it giving us more problems than it is worth?
>
> Having said all that, within the context of the current codebase
> where autocrlf refuses to do the conversion, I agree that teaching
> blame to follow the same logic makes sense. Let me review the
> series up to 6/7 with fresh eyes.
And for the same reason 7/7 may make sense (I didn't check the
implementation, but I think I understand your motivation well enough
to comment)--if crlf-to-git returns without actually converting upon
next "git add $path", in order to serve a preview of what change you
would be checking in and/or committing when you do "git add $path"
and/or "git commit $path", the _to_git() conversion "git diff" and
"git diff HEAD" do on the contents taken from the working tree
should follow the same logic.
"git diff $tree-ish" (of which "git diff HEAD" is a special case) is
a bit tricky to reason about, but I think using the "does index have
CR to cause us refuse conversion?" logic is a sensible thing to do
even in that case. It is asking what difference you would have if
you committed the state in the working tree right now, and the "does
index have CR?" logic to kick in, even though the contents of the
index may not be something that was derived from the unrelated
$tree-ish, would kick in when you make the hypothetical commit to be
compared against $tree-ish.
Again, let me review 7/7 as well with fresh eyes.
Thanks.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1 6/7] correct blame for files commited with CRLF
2016-03-29 20:50 ` Junio C Hamano
@ 2016-03-30 17:48 ` Torsten Bögershausen
0 siblings, 0 replies; 126+ messages in thread
From: Torsten Bögershausen @ 2016-03-30 17:48 UTC (permalink / raw)
To: Junio C Hamano, Torsten Bögershausen; +Cc: git
7/7 needs to be amended with something like this,
and the documentation needs an update.
In any case, the user can normalize the repo like this:
$ 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
$ git add -u
$ git add .gitattributes
$ git commit -m "Introduce end-of-line normalization"
(or run "dos2unix" filename)
----------------
commit a604db36bb946000776514c220964f32979c8756
Author: Torsten Bögershausen <tboegi@web.de>
Date: Wed Mar 30 15:53:52 2016 +0200
convert.c: add warning when eol are wrong after checkout
When line endings are not normalized, they may be different after the
next checkout to what is configured.
Add a warning, similar to the CRLF-LF replacement, when a file is commited,
and the line endings are not converted at commit or checkout.
diff --git a/convert.c b/convert.c
index 8266d87..1fddbe8 100644
--- a/convert.c
+++ b/convert.c
@@ -18,6 +18,8 @@
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
+#define CONVERT_STAT_BITS_MIXED (CONVERT_STAT_BITS_TXT_LF | CONVERT_STAT_BITS_TXT_CRLF)
+
enum crlf_action {
CRLF_UNDEFINED,
CRLF_BINARY,
@@ -279,6 +281,8 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
enum safe_crlf checksafe,
unsigned convert_stats, unsigned new_convert_stats)
{
+ enum eol new_eol = output_eol(crlf_action);
+ const char *err_warn_msg = NULL;
if (!checksafe)
return;
if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF &&
@@ -303,6 +307,19 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
else /* i.e. SAFE_CRLF_FAIL */
die("LF would be replaced by CRLF in %s", path);
}
+ if ((new_convert_stats & CONVERT_STAT_BITS_MIXED) == CONVERT_STAT_BITS_MIXED)
+ err_warn_msg = "mixed eol";
+ else if (new_eol == EOL_LF && new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ err_warn_msg = "CRLF";
+
+ if (err_warn_msg) {
+ if (checksafe == SAFE_CRLF_WARN)
+ warning("%s will be present after commit and checkout in %s.",
+ err_warn_msg, path);
+ else
+ die("%s will be present after commit and checkout in %s",
+ err_warn_msg, path);
+ }
}
[snip changes in t0027]
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v2 1/7] Make it possible to get sha1 for a path from the index
2016-03-07 22:34 ` Junio C Hamano
` (6 preceding siblings ...)
2016-03-29 13:25 ` [PATCH v1 7/7] convert.c: more safer crlf handling with text attribute tboegi
@ 2016-04-01 16:08 ` tboegi
2016-04-01 16:08 ` [PATCH v2 2/7] convert.c: stream and early out tboegi
` (57 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-01 16:08 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Factor out the retrieval of the sha1 for a given path in
read_blob_data_from_index() into the function get_sha1_from_index().
This will be used in the next commit, when convert.c can do the analyze
for "text=auto" without slurping the whole blob into memory at once.
Add a wrapper definition get_sha1_from_cache().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
- Changes against v1:
Fixed typos, thanks Eric
Corrected gitattributes.txt, "auto" will no longer normalize
Rework of 7/7: Show the eol mismatch to the user when committing
---
cache.h | 3 +++
read-cache.c | 29 ++++++++++++++++++-----------
2 files changed, 21 insertions(+), 11 deletions(-)
diff --git a/cache.h b/cache.h
index b829410..bd1210a 100644
--- a/cache.h
+++ b/cache.h
@@ -379,6 +379,7 @@ extern void free_name_hash(struct index_state *istate);
#define unmerge_cache_entry_at(at) unmerge_index_entry_at(&the_index, at)
#define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)
#define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))
+#define get_sha1_from_cache(path) get_sha1_from_index (&the_index, (path))
#endif
enum object_type {
@@ -1008,6 +1009,8 @@ static inline void *read_sha1_file(const unsigned char *sha1, enum object_type *
return read_sha1_file_extended(sha1, type, size, LOOKUP_REPLACE_OBJECT);
}
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path);
+
/*
* This internal function is only declared here for the benefit of
* lookup_replace_object(). Please do not call it directly.
diff --git a/read-cache.c b/read-cache.c
index d9fb78b..a3ef967 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -2263,13 +2263,27 @@ int index_name_is_other(const struct index_state *istate, const char *name,
void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
{
- int pos, len;
+ const unsigned char *sha1;
unsigned long sz;
enum object_type type;
void *data;
- len = strlen(path);
- pos = index_name_pos(istate, path, len);
+ sha1 = get_sha1_from_index(istate, path);
+ if (!sha1)
+ return NULL;
+ data = read_sha1_file(sha1, &type, &sz);
+ if (!data || type != OBJ_BLOB) {
+ free(data);
+ return NULL;
+ }
+ if (size)
+ *size = sz;
+ return data;
+}
+
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path)
+{
+ int pos = index_name_pos(istate, path, strlen(path));
if (pos < 0) {
/*
* We might be in the middle of a merge, in which
@@ -2285,14 +2299,7 @@ void *read_blob_data_from_index(struct index_state *istate, const char *path, un
}
if (pos < 0)
return NULL;
- data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
- if (!data || type != OBJ_BLOB) {
- free(data);
- return NULL;
- }
- if (size)
- *size = sz;
- return data;
+ return (istate->cache[pos]->sha1);
}
void stat_validity_clear(struct stat_validity *sv)
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v2 2/7] convert.c: stream and early out
2016-03-07 22:34 ` Junio C Hamano
` (7 preceding siblings ...)
2016-04-01 16:08 ` [PATCH v2 1/7] Make it possible to get sha1 for a path from the index tboegi
@ 2016-04-01 16:08 ` tboegi
2016-04-01 16:08 ` [PATCH v2 3/7] Allow core.autocrlf=input and core.eol=crlf tboegi
` (56 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-01 16:08 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When statistics are done for the autocrlf handling, the search in
the content can be stopped, if e.g
- a search for binary is done, and a NUL character is found
- a search for CRLF is done, and the first CRLF is found.
Similar when statistics for binary vs non-binary are gathered:
Whenever a lone CR or NUL is found, the search can be aborted.
When checking out files in "auto" mode, any file that has a "lone CR"
or a CRLF will not be converted, so the search can be aborted early.
Add the new bit, CONVERT_STAT_BITS_ANY_CR,
which is set for either lone CR or CRLF.
Many binary files have a NUL very early (within the first few bytes,
latest within the first 1..2K).
It is often not necessary to load the whole content of a file or blob
into memory.
Use a streaming handling for blobs and files in the worktree.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 162 ++++++++++++++++++++++++++++++++++++++++----------------------
1 file changed, 106 insertions(+), 56 deletions(-)
diff --git a/convert.c b/convert.c
index f524b8d..b6da114 100644
--- a/convert.c
+++ b/convert.c
@@ -3,6 +3,7 @@
#include "run-command.h"
#include "quote.h"
#include "sigchain.h"
+#include "streaming.h"
/*
* convert.c - convert a file when checking it out and checking it in.
@@ -13,10 +14,10 @@
* translation when the "text" attribute or "auto_crlf" option is set.
*/
-/* Stat bits: When BIN is set, the txt bits are unset */
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
+#define CONVERT_STAT_BITS_ANY_CR 0x8
enum crlf_action {
CRLF_UNDEFINED,
@@ -31,30 +32,36 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned nul, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonecr, lonelf, crlf;
/* These are just approximations! */
unsigned printable, nonprintable;
};
-static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
+static void do_gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
{
unsigned long i;
- memset(stats, 0, sizeof(*stats));
-
+ if (!buf || !size)
+ return;
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
+ stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
stats->crlf++;
i++;
- } else
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
+ } else {
stats->lonecr++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+ }
continue;
}
if (c == '\n') {
stats->lonelf++;
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_LF;
continue;
}
if (c == 127)
@@ -67,7 +74,7 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
stats->printable++;
break;
case 0:
- stats->nul++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
/* fall through */
default:
stats->nonprintable++;
@@ -75,6 +82,8 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
}
else
stats->printable++;
+ if (stats->stat_bits & earlyout)
+ break; /* We found what we have been searching for */
}
/* If file ends with EOF then don't count this EOF as non-printable. */
@@ -86,41 +95,63 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
* The same heuristics as diff.c::mmfile_is_binary()
* We treat files with bare CR as binary
*/
-static int convert_is_binary(unsigned long size, const struct text_stat *stats)
+static void convert_nonprintable(struct text_stat *stats)
{
- if (stats->lonecr)
- return 1;
- if (stats->nul)
- return 1;
if ((stats->printable >> 7) < stats->nonprintable)
- return 1;
- return 0;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+}
+
+static void gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
+{
+ memset(stats, 0, sizeof(*stats));
+ do_gather_stats(buf, size, stats, earlyout);
+ convert_nonprintable(stats);
}
-static unsigned int gather_convert_stats(const char *data, unsigned long size)
+
+static unsigned get_convert_stats_sha1(const char *path,
+ unsigned const char *sha1,
+ unsigned earlyout)
{
+ struct git_istream *st;
struct text_stat stats;
- int ret = 0;
- if (!data || !size)
- return 0;
- gather_stats(data, size, &stats);
- if (convert_is_binary(size, &stats))
- ret |= CONVERT_STAT_BITS_BIN;
- if (stats.crlf)
- ret |= CONVERT_STAT_BITS_TXT_CRLF;
- if (stats.lonelf)
- ret |= CONVERT_STAT_BITS_TXT_LF;
+ enum object_type type;
+ unsigned long sz;
- return ret;
+ if (!sha1)
+ return 0;
+ memset(&stats, 0, sizeof(stats));
+ st = open_istream(sha1, &type, &sz, NULL);
+ if (!st) {
+ return 0;
+ }
+ if (type != OBJ_BLOB)
+ goto close_and_exit_i;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read_istream(st, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+close_and_exit_i:
+ close_istream(st);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
}
-static const char *gather_convert_stats_ascii(const char *data, unsigned long size)
+static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned int convert_stats = gather_convert_stats(data, size);
-
+ unsigned mask = CONVERT_STAT_BITS_TXT_LF |
+ CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats) {
+ switch (convert_stats & mask) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -132,24 +163,46 @@ static const char *gather_convert_stats_ascii(const char *data, unsigned long si
}
}
+static unsigned get_convert_stats_wt(const char *path)
+{
+ struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ int fd;
+ memset(&stats, 0, sizeof(stats));
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ return 0;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read(fd, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+ close(fd);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
+}
+
const char *get_cached_convert_stats_ascii(const char *path)
{
- const char *ret;
- unsigned long sz;
- void *data = read_blob_data_from_cache(path, &sz);
- ret = gather_convert_stats_ascii(data, sz);
- free(data);
- return ret;
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(path,
+ get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
}
const char *get_wt_convert_stats_ascii(const char *path)
{
- const char *ret = "";
- struct strbuf sb = STRBUF_INIT;
- if (strbuf_read_file(&sb, path, 0) >= 0)
- ret = gather_convert_stats_ascii(sb.buf, sb.len);
- strbuf_release(&sb);
- return ret;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_wt(path);
+ return convert_stats_ascii(convert_stats);
}
static int text_eol_is_crlf(void)
@@ -219,16 +272,11 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
static int has_cr_in_index(const char *path)
{
- unsigned long sz;
- void *data;
- int has_cr;
-
- data = read_blob_data_from_cache(path, &sz);
- if (!data)
- return 0;
- has_cr = memchr(data, '\r', sz) != NULL;
- free(data);
- return has_cr;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_sha1(path,
+ get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_ANY_CR);
+ return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -249,10 +297,10 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
@@ -309,11 +357,13 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
+
if (!len || output_eol(crlf_action) != EOL_CRLF)
return 0;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, earlyout);
/* No "naked" LF? Nothing to convert, regardless. */
if (!stats.lonelf)
@@ -327,7 +377,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
}
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
}
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v2 3/7] Allow core.autocrlf=input and core.eol=crlf
2016-03-07 22:34 ` Junio C Hamano
` (8 preceding siblings ...)
2016-04-01 16:08 ` [PATCH v2 2/7] convert.c: stream and early out tboegi
@ 2016-04-01 16:08 ` tboegi
2016-04-01 22:20 ` Junio C Hamano
2016-04-01 16:08 ` [PATCH v2 4/7] t0027: TC for combined attributes tboegi
` (55 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-01 16:08 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Commit 942e77 "Add "core.eol" config variable" adds a condition to
the config parser: core.autocrlf=input is not allowed together with
core.eol=crlf.
This may lead to unnecessary problems, when config files are parsed:
A global config file sets core.autocrlf=input,
the repo local config file sets is own configuration: core.eol=crlf
There is no need to prevent combinations in config.c, in any case
core.autocrlf overrides core.eol.
Allow all combinations of core.crlf and core.eol and document
that core.autocrlf overrides core.eol.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 6 +++---
config.c | 4 ----
2 files changed, 3 insertions(+), 7 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 2cd6bdd..4a27ad4 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -337,9 +337,9 @@ core.quotePath::
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
+ files that have the `text` property set when core.autocrlf is false.
+ 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.
diff --git a/config.c b/config.c
index 9ba40bc..a6adc8b 100644
--- a/config.c
+++ b/config.c
@@ -803,8 +803,6 @@ static int git_default_core_config(const char *var, const char *value)
if (!strcmp(var, "core.autocrlf")) {
if (value && !strcasecmp(value, "input")) {
- if (core_eol == EOL_CRLF)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
auto_crlf = AUTO_CRLF_INPUT;
return 0;
}
@@ -830,8 +828,6 @@ static int git_default_core_config(const char *var, const char *value)
core_eol = EOL_NATIVE;
else
core_eol = EOL_UNSET;
- if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
return 0;
}
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v2 4/7] t0027: TC for combined attributes
2016-03-07 22:34 ` Junio C Hamano
` (9 preceding siblings ...)
2016-04-01 16:08 ` [PATCH v2 3/7] Allow core.autocrlf=input and core.eol=crlf tboegi
@ 2016-04-01 16:08 ` tboegi
2016-04-01 22:22 ` Junio C Hamano
2016-04-01 16:08 ` [PATCH v2 5/7] CRLF: unify the "auto" handling tboegi
` (54 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-01 16:08 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Add more test cases for the not normalized files ("NNO").
The "text" attribute is most important, use it as the first parameter.
"ident", if set, is the second paramater followed by the eol attribute.
The eol attribute overrides core.autocrlf, which overrides core.eol.
Use loops to test more combinations of attributes, like
"* text eol=crlf" or especially "*text=auto eol=crlf".
Currently "* text=auto eol=lf" does the same as "* text eol=lf", as the
eol attribute overrides "text=auto", this will change in future.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t0027-auto-crlf.sh | 321 +++++++++++++++++++++++++--------------------------
1 file changed, 158 insertions(+), 163 deletions(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index f33962b..55f45d3 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -52,14 +52,17 @@ create_gitattributes () {
create_NNO_files () {
for crlf in false true input
do
- for attr in "" auto text -text lf crlf
+ for attr in "" auto text -text
do
- pfx=NNO_${crlf}_attr_${attr} &&
- cp CRLF_mix_LF ${pfx}_LF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
- cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ for aeol in "" lf crlf
+ do
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ cp CRLF_mix_LF ${pfx}_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ done
done
done
}
@@ -100,16 +103,17 @@ commit_check_warn () {
}
commit_chk_wrnNNO () {
- crlf=$1
- attr=$2
- lfwarn=$3
- crlfwarn=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfwarn=$1 ; shift
+ crlfwarn=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
#Commit files on top of existing file
- create_gitattributes "$attr" &&
+ create_gitattributes "$attr" $aeol &&
for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
do
fname=${pfx}_$f.txt &&
@@ -121,19 +125,19 @@ commit_chk_wrnNNO () {
test_expect_success "commit NNO files crlf=$crlf attr=$attr LF" '
check_warning "$lfwarn" ${pfx}_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF" '
check_warning "$crlfwarn" ${pfx}_CRLF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_mix_LF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_mix_LF" '
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr LF_mix_cr" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf LF_mix_cr" '
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_nul" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_nul" '
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
'
}
@@ -162,6 +166,7 @@ stats_ascii () {
# contruct the attr/ returned by git ls-files --eol
# Take none (=empty), one or two args
+# convert.c: eol=XX overrides text=auto
attr_ascii () {
case $1,$2 in
-text,*) echo "-text" ;;
@@ -169,8 +174,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text=auto eol=lf" ;;
- auto,crlf) echo "text=auto eol=crlf" ;;
+ auto,lf) echo "text eol=lf" ;;
+ auto,crlf) echo "text eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -195,28 +200,29 @@ check_files_in_repo () {
}
check_in_repo_NNO () {
- crlf=$1
- attr=$2
- lfname=$3
- crlfname=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}_
- test_expect_success "compare_files $lfname ${pfx}LF.txt" '
- compare_files $lfname ${pfx}LF.txt
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfname=$1 ; shift
+ crlfname=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ test_expect_success "compare_files $lfname ${pfx}_LF.txt" '
+ compare_files $lfname ${pfx}_LF.txt
'
- test_expect_success "compare_files $crlfname ${pfx}CRLF.txt" '
- compare_files $crlfname ${pfx}CRLF.txt
+ test_expect_success "compare_files $crlfname ${pfx}_CRLF.txt" '
+ compare_files $crlfname ${pfx}_CRLF.txt
'
- test_expect_success "compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt" '
- compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt
+ test_expect_success "compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt" '
+ compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt
'
- test_expect_success "compare_files $lfmixcr ${pfx}LF_mix_CR.txt" '
- compare_files $lfmixcr ${pfx}LF_mix_CR.txt
+ test_expect_success "compare_files $lfmixcr ${pfx}_LF_mix_CR.txt" '
+ compare_files $lfmixcr ${pfx}_LF_mix_CR.txt
'
- test_expect_success "compare_files $crlfnul ${pfx}CRLF_nul.txt" '
- compare_files $crlfnul ${pfx}CRLF_nul.txt
+ test_expect_success "compare_files $crlfnul ${pfx}_CRLF_nul.txt" '
+ compare_files $crlfnul ${pfx}_CRLF_nul.txt
'
}
@@ -231,7 +237,7 @@ checkout_files () {
lfmixcrlf=$1 ; shift
lfmixcr=$1 ; shift
crlfnul=$1 ; shift
- create_gitattributes "$attr" "$ident" &&
+ create_gitattributes "$attr" $ident $aeol &&
git config core.autocrlf $crlf &&
pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
@@ -244,7 +250,7 @@ checkout_files () {
fi
done
- test_expect_success "ls-files --eol attr=$attr $ident $aeol core.autocrlf=$crlf core.eol=$ceol" '
+ test_expect_success "ls-files --eol attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol" '
test_when_finished "rm expect actual" &&
sort <<-EOF >expect &&
i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
@@ -385,31 +391,31 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
-commit_chk_wrnNNO false "" "" "" "" "" ""
-commit_chk_wrnNNO true "" "LF_CRLF" "" "" "" ""
-commit_chk_wrnNNO input "" "" "" "" "" ""
-
+# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+commit_chk_wrnNNO "" "" false "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO false "auto" "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO true "auto" "LF_CRLF" "" "LF_CRLF" "" ""
-commit_chk_wrnNNO input "auto" "" "CRLF_LF" "CRLF_LF" "" ""
+commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-commit_chk_wrnNNO false "text" "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO true "text" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "text" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-
-commit_chk_wrnNNO false "-text" "" "" "" "" ""
-commit_chk_wrnNNO true "-text" "" "" "" "" ""
-commit_chk_wrnNNO input "-text" "" "" "" "" ""
-
-commit_chk_wrnNNO false "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO true "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO input "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
+for crlf in true false input;
+do
+ commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+done
-commit_chk_wrnNNO false "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO true "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
test_expect_success 'create files cleanup' '
rm -f *.txt &&
@@ -440,24 +446,20 @@ test_expect_success 'commit -text' '
check_files_in_repo input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
'
-# attr LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
-check_in_repo_NNO false "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "auto" LF LF LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO true "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO input "text" LF LF LF LF_mix_CR LF_nul
-
-check_in_repo_NNO false "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-
+for crlf in true false input;
+do
+ # attr aeol LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
+ check_in_repo_NNO "" "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+done
################################################################################
# Check how files in the repo are changed when they are checked out
# How to read the table below:
@@ -489,89 +491,82 @@ LFNUL=LF_nul
fi
export CRLF_MIX_LF_CR MIX NL
-checkout_files "" "" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true "" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true crlf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true lf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true native CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true "" CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true lf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true native CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-
+# Same handling with and without ident
for id in "" ident;
do
- checkout_files "crlf" "$id" "" false "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "lf" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "-text" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # -text overrides core.autocrlf and core.eol
+ # text and eol=crlf or eol=lf override core.autocrlf and core.eol
+ for crlf in true false input;
+ do
+ for ceol in "" lf crlf native;
+ do
+ checkout_files "-text" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "text" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+ done
+ # text: core.autocrlf=false uses core.eol
+ checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files "auto" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files "auto" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+
+ for ceol in "" lf crlf native;
+ do
+ # text: core.autocrlf = true overrides core.eol
+ checkout_files "text" "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # text: core.autocrlf = input overrides core.eol
+ checkout_files "text" "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ done
+ # No text attr
+ for ceol in "" lf crlf native;
+ do
+ # core.autocrlf!=true gives LF (or mixed) at checkout
+ for crlf in false input;
+ do
+ checkout_files "" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ done
+ done
+done
+
+#Handling without ident
+for id in "";
+do
+ for ceol in "" lf crlf native;
+ do
+ # core.autocrlf=true
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ # text=auto + eol=XXX
+ # currently the same as text, eol=XXX
+ checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+done
+
+#Handling with ident
+for id in ident;
+do
+ for crlf in "" true false input;
+ do
+ for ceol in "" lf crlf native;
+ do
+ # ident does not react on core.autocrlf=true
+ checkout_files "" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # ident does not react on text=auto
+ checkout_files "auto" "$id" "" true "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text=auto + eol=XXX
+ # currently the same as text, eol=XXX
+ checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+ done
done
# Should be the last test case: remove some files from the worktree
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v2 5/7] CRLF: unify the "auto" handling
2016-03-07 22:34 ` Junio C Hamano
` (10 preceding siblings ...)
2016-04-01 16:08 ` [PATCH v2 4/7] t0027: TC for combined attributes tboegi
@ 2016-04-01 16:08 ` tboegi
2016-04-01 22:25 ` Junio C Hamano
2016-04-01 16:08 ` [PATCH v2 6/7] correct blame for files commited with CRLF tboegi
` (53 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-01 16:08 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Make .gitattributes "* text=auto eol=crlf" to do the same as
setting core.autocrlf=true and "* text=auto eol=crlf" the same
as core.autocrlf=input
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 10 ++++-----
Documentation/gitattributes.txt | 11 +++++-----
convert.c | 37 ++++++++++++++++-----------------
t/t0025-crlf-auto.sh | 4 ++--
t/t0027-auto-crlf.sh | 45 +++++++++++++++++++----------------------
5 files changed, 53 insertions(+), 54 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 4a27ad4..dfaf39c 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -389,13 +389,13 @@ 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
+ Setting this variable to "true" is the same as setting
+ the attributes to "auto eol=crlf" on all files.
+ 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',
+ working directory and the repository has normalized line endings.
+ This variable can be set to 'input',
in which case no output conversion is performed.
core.symlinks::
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index e3b1de8..c2663c7 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -115,6 +115,7 @@ 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.eol` configuration variable for all text files.
+Note that `core.autocrlf` overrides `core.eol`
Set::
@@ -146,8 +147,8 @@ 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, effectively setting the `text` attribute.
+working directory. It sets the `text` attribute,
+unless `text=auto` is specified.
Set to string value "crlf"::
@@ -187,8 +188,8 @@ regardless of their content.
------------------------
*.txt text
-*.vcproj eol=crlf
-*.sh eol=lf
+*.vcproj text eol=crlf
+*.sh text eol=lf
*.jpg -text
------------------------
@@ -198,7 +199,7 @@ 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.
+config variable "core.autocrlf" without using any attributes.
------------------------
[core]
diff --git a/convert.c b/convert.c
index b6da114..4ed5d89 100644
--- a/convert.c
+++ b/convert.c
@@ -229,7 +229,9 @@ static enum eol output_eol(enum crlf_action crlf_action)
return EOL_LF;
case CRLF_UNDEFINED:
case CRLF_AUTO_CRLF:
+ return EOL_CRLF;
case CRLF_AUTO_INPUT:
+ return EOL_LF;
case CRLF_TEXT:
case CRLF_AUTO:
/* fall through */
@@ -302,15 +304,12 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
-
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /*
- * 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 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, crlf_action, &stats, checksafe);
@@ -370,12 +369,10 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
- }
+ /* If we have any CR or CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (stats.lonecr || stats.crlf )
+ return 0;
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
@@ -836,7 +833,11 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
ca->drv = git_path_check_convert(ccheck + 2);
if (ca->crlf_action != CRLF_BINARY) {
enum eol eol_attr = git_path_check_eol(ccheck + 3);
- if (eol_attr == EOL_LF)
+ if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_LF)
+ ca->crlf_action = CRLF_AUTO_INPUT;
+ else if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_CRLF)
+ ca->crlf_action = CRLF_AUTO_CRLF;
+ else if (eol_attr == EOL_LF)
ca->crlf_action = CRLF_TEXT_INPUT;
else if (eol_attr == EOL_CRLF)
ca->crlf_action = CRLF_TEXT_CRLF;
@@ -895,9 +896,9 @@ const char *get_convert_attr_ascii(const char *path)
case CRLF_AUTO:
return "text=auto";
case CRLF_AUTO_CRLF:
- return "text=auto eol=crlf"; /* This is not supported yet */
+ return "text=auto eol=crlf";
case CRLF_AUTO_INPUT:
- return "text=auto eol=lf"; /* This is not supported yet */
+ return "text=auto eol=lf";
}
return "";
}
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index c164b46..d0bee08 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -114,7 +114,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
+test_expect_success 'text=auto, autocrlf=true does not normalize CRLF files' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
git config core.autocrlf true &&
@@ -126,7 +126,7 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
LFonlydiff=$(git diff LFonly) &&
CRLFonlydiff=$(git diff CRLFonly) &&
LFwithNULdiff=$(git diff LFwithNUL) &&
- test -z "$LFonlydiff" -a -n "$CRLFonlydiff" -a -z "$LFwithNULdiff"
+ test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 55f45d3..86175cf 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -174,8 +174,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text eol=lf" ;;
- auto,crlf) echo "text eol=crlf" ;;
+ auto,lf) echo "text=auto eol=lf" ;;
+ auto,crlf) echo "text=auto eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -396,10 +396,9 @@ commit_chk_wrnNNO "" "" false "" "" "" ""
commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
-commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-
+commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input;
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
@@ -407,8 +406,8 @@ do
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
done
@@ -453,9 +452,9 @@ do
check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
@@ -513,8 +512,6 @@ do
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "auto" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "auto" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
for ceol in "" lf crlf native;
do
@@ -541,30 +538,30 @@ do
for ceol in "" lf crlf native;
do
# core.autocrlf=true
- checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "auto" "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text=auto + eol=XXX
- # currently the same as text, eol=XXX
- checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
done
#Handling with ident
for id in ident;
do
- for crlf in "" true false input;
+ for crlf in true false input;
do
for ceol in "" lf crlf native;
do
# ident does not react on core.autocrlf=true
- checkout_files "" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# ident does not react on text=auto
- checkout_files "auto" "$id" "" true "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "" true "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text=auto + eol=XXX
- # currently the same as text, eol=XXX
- checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "auto" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "auto" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
done
done
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v2 6/7] correct blame for files commited with CRLF
2016-03-07 22:34 ` Junio C Hamano
` (11 preceding siblings ...)
2016-04-01 16:08 ` [PATCH v2 5/7] CRLF: unify the "auto" handling tboegi
@ 2016-04-01 16:08 ` tboegi
2016-04-01 22:29 ` Junio C Hamano
2016-04-01 16:08 ` [PATCH v2 7/7] convert.c: more safer crlf handling with text attribute tboegi
` (52 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-01 16:08 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
git blame reports lines as not "Not Committed Yet" when they have
CRLF in the index, CRLF in the worktree and e.g. core.autocrlf is true.
Since commit c48053 "new safer autocrlf handling", files that have CRLF
in the index are not normalized at commit when e.g. core.autocrl is set.
Whenever a CLRF conversion is needed (or any filter us set), load the
index temporally, before calling convert_to_git()
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
builtin/blame.c | 6 +++++-
convert.c | 10 ++++++++++
convert.h | 1 +
t/t8003-blame-corner-cases.sh | 14 ++++++++++++++
4 files changed, 30 insertions(+), 1 deletion(-)
diff --git a/builtin/blame.c b/builtin/blame.c
index e982fb8..a219068 100644
--- a/builtin/blame.c
+++ b/builtin/blame.c
@@ -2376,7 +2376,11 @@ static struct commit *fake_working_tree_commit(struct diff_options *opt,
if (strbuf_read(&buf, 0, 0) < 0)
die_errno("failed to read from stdin");
}
- convert_to_git(path, buf.buf, buf.len, &buf, 0);
+ if (convert_needs_conversion(path)) {
+ read_cache();
+ convert_to_git(path, buf.buf, buf.len, &buf, 0);
+ discard_cache();
+ }
origin->file.ptr = buf.buf;
origin->file.size = buf.len;
pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_sha1);
diff --git a/convert.c b/convert.c
index 4ed5d89..02c50da 100644
--- a/convert.c
+++ b/convert.c
@@ -903,6 +903,16 @@ const char *get_convert_attr_ascii(const char *path)
return "";
}
+int convert_needs_conversion(const char *path)
+{
+ struct conv_attrs ca;
+
+ convert_attrs(&ca, path);
+ if (ca.drv || ca.ident || ca.crlf_action != CRLF_BINARY)
+ return 1;
+ return 0;
+}
+
int convert_to_git(const char *path, const char *src, size_t len,
struct strbuf *dst, enum safe_crlf checksafe)
{
diff --git a/convert.h b/convert.h
index ccf436b..ffd9c32 100644
--- a/convert.h
+++ b/convert.h
@@ -35,6 +35,7 @@ extern enum eol core_eol;
extern const char *get_cached_convert_stats_ascii(const char *path);
extern const char *get_wt_convert_stats_ascii(const char *path);
extern const char *get_convert_attr_ascii(const char *path);
+int convert_needs_conversion(const char *path);
/* returns 1 if *dst was used */
extern int convert_to_git(const char *path, const char *src, size_t len,
diff --git a/t/t8003-blame-corner-cases.sh b/t/t8003-blame-corner-cases.sh
index 6568429..a9b266f 100755
--- a/t/t8003-blame-corner-cases.sh
+++ b/t/t8003-blame-corner-cases.sh
@@ -212,4 +212,18 @@ test_expect_success 'blame file with CRLF attributes text' '
grep "A U Thor" actual
'
+test_expect_success 'blame file with CRLF core.autocrlf=true' '
+ git config core.autocrlf false &&
+ printf "testcase\r\n" >crlfinrepo &&
+ >.gitattributes &&
+ git add crlfinrepo &&
+ git commit -m "add crlfinrepo" &&
+ git config core.autocrlf true &&
+ mv crlfinrepo tmp &&
+ git checkout crlfinrepo &&
+ rm tmp &&
+ git blame crlfinrepo >actual &&
+ grep "A U Thor" actual
+'
+
test_done
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v2 7/7] convert.c: more safer crlf handling with text attribute
2016-03-07 22:34 ` Junio C Hamano
` (12 preceding siblings ...)
2016-04-01 16:08 ` [PATCH v2 6/7] correct blame for files commited with CRLF tboegi
@ 2016-04-01 16:08 ` tboegi
2016-04-05 19:23 ` [PATCH v1] correct blame for files commited with CRLF tboegi
` (51 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-01 16:08 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
A follow-up after a discussion how to fix the flaky execution
of t0025, gmane/$284352.
This patch extends the work done in commit c480539:
"Make it work also for un-normalized repositories". Make sure that CRLF
can be converted round trip, or don't convert them at all.
The old handling would treat a file as unchanged after checkout,
as long as it is not touched in the work tree and mtime matches the value
recorded in the index.
When the mtime is changed in the working tree, or the inode is changed,
the file is reported as modified.
The following sequence is now handled reproducable:
$ git init
$ printf "line1\r\n" >file.bat
$ git add file.bat
$ git commit -m "Add file with CRLF" file.bat
$ echo "*.bat text eol=crlf" >.gitattributes
$ git commit -m "bat files should have CRLF"
$ git status
# nothing to commit, working directory clean
$ git push <upstream>
$ printf "newline\r\n" >>file.bat
$ mv file.bat file.sav
$ git checkout file.bat
$ git status
#modified: file.bat
The new handling makes sure that after running "git reset --hard".
"git status" reports the working tree as clean regarding CRLF conversion.
It makes sure that the Git-internal eol conversion is
doing roundtrip. A user can still write an external smudge/clean filter
outside Git, which doesn't do a roundtrip and the working directory is
not clean.
The functionality of has_cr_in_index() is turned into has_crlf_in_index(),
and the function is integrated into would_convert_crlf_at_commit().
Check for CRLF in the index instead of CR, the bit CONVERT_STAT_BITS_ANY_CR
is no longer used and removed, as well as "lonecr" in struct text_stat.
Rewrite check_safe_crlf() in convert.c to simulate checkin-checkout,
to detect whether any line endings are converted.
Add a warning, similar to the CRLF-LF replacement, when a file is commited,
and after the next checkout the line endings are not they should be.
Modify the lf_to_crlf_filter:
Files with LF are converted into CRLF, file with CRLF are not changed.
Files with mixed line endings are not converted, the filter fails, and Git
falls back to the non-streaming handling, see write_entry().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/gitattributes.txt | 16 ++-
convert.c | 232 +++++++++++++++++++++++++---------------
t/t0025-crlf-auto.sh | 8 +-
t/t0027-auto-crlf.sh | 58 +++++-----
4 files changed, 191 insertions(+), 123 deletions(-)
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index c2663c7..3caeb52 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -110,7 +110,7 @@ repository upon 'git add' and 'git commit'.
`text`
^^^^^^
-This attribute enables and controls end-of-line normalization. When a
+This attribute enables and controls end-of-line conversion. 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
@@ -120,8 +120,11 @@ Note that `core.autocrlf` overrides `core.eol`
Set::
Setting the `text` attribute on a path enables end-of-line
- normalization and marks the path as a text file. End-of-line
+ conversion and marks the path as a text file. End-of-line
conversion takes place without guessing the content type.
+ Files that have been commited with CRLF before the text attribute
+ is set and commited are not normalized. No end-of-line conversion
+ is done at checkout or checkin.
Unset::
@@ -132,7 +135,8 @@ Set to string value "auto"::
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.
+ text, and the path has no CRLF in the index,
+ its line endings are converted to LF on checkin.
Unspecified::
@@ -147,8 +151,10 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It sets the `text` attribute,
-unless `text=auto` is specified.
+working directory. It sets the `text` attribute, unless `text=auto`
+is specified.
+When the file had been commited with CRLF in the index, no conversion
+is done at checkout or commit.
Set to string value "crlf"::
diff --git a/convert.c b/convert.c
index 02c50da..1fddbe8 100644
--- a/convert.c
+++ b/convert.c
@@ -17,7 +17,8 @@
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
-#define CONVERT_STAT_BITS_ANY_CR 0x8
+
+#define CONVERT_STAT_BITS_MIXED (CONVERT_STAT_BITS_TXT_LF | CONVERT_STAT_BITS_TXT_CRLF)
enum crlf_action {
CRLF_UNDEFINED,
@@ -32,7 +33,7 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned stat_bits, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonelf;
/* These are just approximations! */
unsigned printable, nonprintable;
@@ -48,13 +49,10 @@ static void do_gather_stats(const char *buf, unsigned long size,
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
- stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
- stats->crlf++;
i++;
stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
} else {
- stats->lonecr++;
stats->stat_bits |= CONVERT_STAT_BITS_BIN;
}
continue;
@@ -136,7 +134,7 @@ static unsigned get_convert_stats_sha1(const char *path,
if (!readlen)
break;
do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
- if (stats.stat_bits & earlyout)
+ if ((stats.stat_bits & earlyout) == earlyout)
break; /* We found what we have been searching for */
}
close_and_exit_i:
@@ -147,11 +145,9 @@ close_and_exit_i:
static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned mask = CONVERT_STAT_BITS_TXT_LF |
- CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats & mask) {
+ switch (convert_stats) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -163,7 +159,17 @@ static const char *convert_stats_ascii(unsigned convert_stats)
}
}
-static unsigned get_convert_stats_wt(const char *path)
+const char *get_cached_convert_stats_ascii(const char *path)
+{
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(path,
+ get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
+}
+
+const char *get_wt_convert_stats_ascii(const char *path)
{
struct text_stat stats;
unsigned earlyout = CONVERT_STAT_BITS_BIN;
@@ -185,24 +191,7 @@ static unsigned get_convert_stats_wt(const char *path)
}
close(fd);
convert_nonprintable(&stats);
- return stats.stat_bits;
-}
-
-const char *get_cached_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- unsigned earlyout = CONVERT_STAT_BITS_BIN;
- convert_stats = get_convert_stats_sha1(path,
- get_sha1_from_cache(path),
- earlyout);
- return convert_stats_ascii(convert_stats);
-}
-
-const char *get_wt_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_wt(path);
- return convert_stats_ascii(convert_stats);
+ return convert_stats_ascii(stats.stat_bits);
}
static int text_eol_is_crlf(void)
@@ -241,44 +230,96 @@ static enum eol output_eol(enum crlf_action crlf_action)
return core_eol;
}
+static int would_convert_lf_at_checkout(unsigned convert_stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ if (output_eol(crlf_action) != EOL_CRLF)
+ return 0;
+
+ /* No "naked" LF? Nothing to convert, regardless. */
+ if (!convert_stats & CONVERT_STAT_BITS_TXT_LF)
+ return 0;
+
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ /* auto: binary files are not converted */
+ if (convert_stats & CONVERT_STAT_BITS_BIN)
+ return 0;
+ }
+ /* If we have any CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+
+}
+
+static int would_convert_crlf_at_commit(const char * path,
+ const struct text_stat *stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ unsigned stat_bits_index;
+ /* No CRLF? Nothing to convert, regardless. */
+ if (!(stats->stat_bits & CONVERT_STAT_BITS_TXT_CRLF))
+ return 0;
+ /*
+ * If the file in the index has any CRLF in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ stat_bits_index = get_convert_stats_sha1(path,
+ get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_TXT_CRLF);
+ if (stat_bits_index & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+}
+
static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
- struct text_stat *stats, enum safe_crlf checksafe)
+ enum safe_crlf checksafe,
+ unsigned convert_stats, unsigned new_convert_stats)
{
+ enum eol new_eol = output_eol(crlf_action);
+ const char *err_warn_msg = NULL;
if (!checksafe)
return;
-
- if (output_eol(crlf_action) == EOL_LF) {
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
/*
* 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.\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 (output_eol(crlf_action) == EOL_CRLF) {
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if (convert_stats & CONVERT_STAT_BITS_TXT_LF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_LF)) {
/*
* CRLFs would be added by checkout:
* check if we have "naked" LFs
*/
- if (stats->lonelf) {
- if (checksafe == SAFE_CRLF_WARN)
- 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);
- }
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if ((new_convert_stats & CONVERT_STAT_BITS_MIXED) == CONVERT_STAT_BITS_MIXED)
+ err_warn_msg = "mixed eol";
+ else if (new_eol == EOL_LF && new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ err_warn_msg = "CRLF";
+
+ if (err_warn_msg) {
+ if (checksafe == SAFE_CRLF_WARN)
+ warning("%s will be present after commit and checkout in %s.",
+ err_warn_msg, path);
+ else
+ die("%s will be present after commit and checkout in %s",
+ err_warn_msg, path);
}
-}
-
-static int has_cr_in_index(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_sha1(path,
- get_sha1_from_cache(path),
- CONVERT_STAT_BITS_ANY_CR);
- return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -287,7 +328,7 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
{
struct text_stat stats;
char *dst;
-
+ int convert_crlf;
if (crlf_action == CRLF_BINARY ||
(src && !len))
return 0;
@@ -299,23 +340,36 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
-
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
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;
+ } else {
+ gather_stats(src, len, &stats, 0);
}
-
- check_safe_crlf(path, crlf_action, &stats, checksafe);
-
- /* Optimization: No CRLF? Nothing to convert, regardless. */
- if (!stats.crlf)
+ convert_crlf = would_convert_crlf_at_commit(path, &stats, len,
+ crlf_action);
+ if (checksafe) {
+ unsigned convert_stats = stats.stat_bits;
+ unsigned new_convert_stats = convert_stats;
+ /* Simulate commit */
+ if (convert_crlf &&
+ (new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_LF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_CRLF;
+ }
+ /* Simulate checkout */
+ if (would_convert_lf_at_checkout(new_convert_stats,
+ len, crlf_action)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_CRLF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_LF;
+ }
+ check_safe_crlf(path, crlf_action, checksafe,
+ convert_stats, new_convert_stats);
+ }
+ if (!convert_crlf)
return 0;
/*
@@ -329,7 +383,9 @@ 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 (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
/*
* If we guessed, we already know we rejected a file with
* lone CR, and we can strip a CR without looking at what
@@ -356,28 +412,15 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
- unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
-
-
- if (!len || output_eol(crlf_action) != EOL_CRLF)
+ unsigned earlyout = 0; /* Need to count lonelf */
+ if (!len)
return 0;
gather_stats(src, len, &stats, earlyout);
-
- /* No "naked" LF? Nothing to convert, regardless. */
- if (!stats.lonelf)
+ if (!would_convert_lf_at_checkout(stats.stat_bits,
+ len, crlf_action))
return 0;
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
-
- if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
- return 0;
- }
-
/* are we "faking" in place editing ? */
if (src == buf->buf)
to_free = strbuf_detach(buf, NULL);
@@ -1079,6 +1122,8 @@ int is_null_stream_filter(struct stream_filter *filter)
struct lf_to_crlf_filter {
struct stream_filter filter;
unsigned has_held:1;
+ unsigned expanded_loneLF:1;
+ unsigned had_CRLF:1;
char held;
};
@@ -1119,7 +1164,12 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
char ch = input[i];
if (ch == '\n') {
- output[o++] = '\r';
+ if (!lf_to_crlf->had_CRLF) {
+ output[o++] = '\r';
+ lf_to_crlf->expanded_loneLF = 1;
+ }
+ if (was_cr)
+ lf_to_crlf->had_CRLF = 1;
} else if (was_cr) {
/*
* Previous round saw CR and it is not followed
@@ -1148,6 +1198,14 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
was_cr = 0;
output[o++] = ch;
+ if (lf_to_crlf->expanded_loneLF &&
+ lf_to_crlf->had_CRLF) {
+ /*
+ * Mixed EOL, round trip not possible.
+ */
+ return 1;
+ }
+
}
*osize_p -= o;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index d0bee08..b5f93e2 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 "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'crlf=true causes a CRLF file to be normalized' '
+test_expect_success 'crlf=true causes a CRLF file not to be normalized' '
# Backwards compatibility check
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
@@ -49,10 +49,10 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
-test_expect_success 'text=true causes a CRLF file to be normalized' '
+test_expect_success 'text=true causes a CRLF file not to be normalized' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
echo "CRLFonly text" > .gitattributes &&
@@ -61,7 +61,7 @@ test_expect_success 'text=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 86175cf..71ca1aa 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -71,10 +71,14 @@ check_warning () {
case "$1" in
LF_CRLF) echo "warning: LF will be replaced by CRLF" >"$2".expect ;;
CRLF_LF) echo "warning: CRLF will be replaced by LF" >"$2".expect ;;
+ CRLF) echo "warning: CRLF will be present after commit and checkout" >"$2".expect ;;
+ mixed) echo "warning: mixed eol will be present after commit and checkout" >"$2".expect ;;
'') >"$2".expect ;;
*) echo >&2 "Illegal 1": "$1" ; return false ;;
esac
- grep "will be replaced by" "$2" | sed -e "s/\(.*\) in [^ ]*$/\1/" | uniq >"$2".actual
+ egrep "will be replaced by|will be present after commit" "$2" |
+ sed -e "s/\(.*\) in [^ ]*$/\1/" |
+ uniq >"$2".actual
test_cmp "$2".expect "$2".actual
}
@@ -354,7 +358,7 @@ else
WAMIX=CRLF_LF
fi
-# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
+# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
test_expect_success 'commit files empty attr' '
commit_check_warn false "" "" "" "" "" "" &&
commit_check_warn true "" "LF_CRLF" "" "LF_CRLF" "" "" &&
@@ -391,30 +395,32 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
commit_chk_wrnNNO "" "" false "" "" "" "" ""
-commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "" "" input "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "" "" input "" CRLF mixed "" ""
-commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
+commit_chk_wrnNNO "auto" "" false "$WILC" CRLF mixed "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF mixed "" ""
for crlf in true false input;
do
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
- commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
- commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" mixed LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF mixed "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" mixed "" ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" mixed LF_CRLF ""
done
-commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
-commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+commit_chk_wrnNNO "text" "" false "$WILC" CRLF mixed "$WILC" CRLF
+commit_chk_wrnNNO "text" "" true LF_CRLF "" mixed LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF mixed "" CRLF
test_expect_success 'create files cleanup' '
rm -f *.txt &&
@@ -455,9 +461,9 @@ do
check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
done
################################################################################
# Check how files in the repo are changed when they are checked out
@@ -478,12 +484,10 @@ done
if test_have_prereq NATIVE_CRLF
then
-MIX_CRLF_LF=CRLF
MIX_LF_CR=CRLF_mix_CR
NL=CRLF
LFNUL=CRLF_nul
else
-MIX_CRLF_LF=CRLF_mix_LF
MIX_LF_CR=LF_mix_CR
NL=LF
LFNUL=LF_nul
@@ -503,20 +507,20 @@ do
checkout_files "-text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "-text" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "text" "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
done
done
# text: core.autocrlf=false uses core.eol
- checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files "text" "$id" "" false "" $NL CRLF CRLF_mix_LF $MIX_LF_CR $LFNUL
+ checkout_files "text" "$id" "" false native $NL CRLF CRLF_mix_LF $MIX_LF_CR $LFNUL
for ceol in "" lf crlf native;
do
# text: core.autocrlf = true overrides core.eol
- checkout_files "text" "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files "text" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
checkout_files "text" "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "auto" "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH v2 3/7] Allow core.autocrlf=input and core.eol=crlf
2016-04-01 16:08 ` [PATCH v2 3/7] Allow core.autocrlf=input and core.eol=crlf tboegi
@ 2016-04-01 22:20 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-04-01 22:20 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> Commit 942e77 "Add "core.eol" config variable" adds a condition to
> the config parser: core.autocrlf=input is not allowed together with
> core.eol=crlf.
>
> This may lead to unnecessary problems, when config files are parsed:
> A global config file sets core.autocrlf=input,
> the repo local config file sets is own configuration: core.eol=crlf
This paragraph is unparsable. Do you mean
When the global configuration file sets core.autocrlf=input
and the repository local one sets core.eol=crlf, they violate
this condition and triggers an error when the configuration
is read.
I think that is the designed behaviour, so it is not "a problem" at
all, and an example that makes them come from two different sources
of configuration is a red herring. The parser faithfully implement
the policy that the combination is invalid.
The "problem" is in the policy itself, which you address below.
> There is no need to prevent combinations in config.c, in any case
> core.autocrlf overrides core.eol.
So
Even though the configuration parser errors out when
core.autocrlf is set to 'input' when core.eol is set to
'crlf', there is no need to do so, because the core.autocrlf
setting trumps core.eol.
or something like that, perhaps?
> Allow all combinations of core.crlf and core.eol and document
> that core.autocrlf overrides core.eol.
That is a good change.
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
> ---
> Documentation/config.txt | 6 +++---
> config.c | 4 ----
> 2 files changed, 3 insertions(+), 7 deletions(-)
>
> diff --git a/Documentation/config.txt b/Documentation/config.txt
> index 2cd6bdd..4a27ad4 100644
> --- a/Documentation/config.txt
> +++ b/Documentation/config.txt
> @@ -337,9 +337,9 @@ core.quotePath::
>
> 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
> + files that have the `text` property set when core.autocrlf is false.
> + 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.
>
> diff --git a/config.c b/config.c
> index 9ba40bc..a6adc8b 100644
> --- a/config.c
> +++ b/config.c
> @@ -803,8 +803,6 @@ static int git_default_core_config(const char *var, const char *value)
>
> if (!strcmp(var, "core.autocrlf")) {
> if (value && !strcasecmp(value, "input")) {
> - if (core_eol == EOL_CRLF)
> - return error("core.autocrlf=input conflicts with core.eol=crlf");
> auto_crlf = AUTO_CRLF_INPUT;
> return 0;
> }
> @@ -830,8 +828,6 @@ static int git_default_core_config(const char *var, const char *value)
> core_eol = EOL_NATIVE;
> else
> core_eol = EOL_UNSET;
> - if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
> - return error("core.autocrlf=input conflicts with core.eol=crlf");
> return 0;
> }
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v2 4/7] t0027: TC for combined attributes
2016-04-01 16:08 ` [PATCH v2 4/7] t0027: TC for combined attributes tboegi
@ 2016-04-01 22:22 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-04-01 22:22 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> +for crlf in true false input;
Style: lose the ';' at the end (there may be other instances of the
same).
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v2 5/7] CRLF: unify the "auto" handling
2016-04-01 16:08 ` [PATCH v2 5/7] CRLF: unify the "auto" handling tboegi
@ 2016-04-01 22:25 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-04-01 22:25 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> Make .gitattributes "* text=auto eol=crlf" to do the same as
> setting core.autocrlf=true and "* text=auto eol=crlf" the same
> as core.autocrlf=input
"Earlier we didn't do so and instead did X, which was not great
because it caused symptom Y and Z"
would be necessary for future readers to understand why the above
change is a good idea.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v2 6/7] correct blame for files commited with CRLF
2016-04-01 16:08 ` [PATCH v2 6/7] correct blame for files commited with CRLF tboegi
@ 2016-04-01 22:29 ` Junio C Hamano
2016-04-03 9:29 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-04-01 22:29 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> Whenever a CLRF conversion is needed (or any filter us set), load the
> index temporally, before calling convert_to_git()
I am not sure if this is needed. We should just do read_cache()
unconditionally at the beginning of fake_working_tree_commit(),
without even discarding it. Most Git commands that work on the
working tree files follow that pattern, and I do not think the
"optimization" this patch does over that simple pattern, while it
may be nice, is an unnecessary complication.
By the way, thanks for pushing back in the [v1 6/7] discussion
thread to show me where convert_to_git() was failing.
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
> ---
> builtin/blame.c | 6 +++++-
> convert.c | 10 ++++++++++
> convert.h | 1 +
> t/t8003-blame-corner-cases.sh | 14 ++++++++++++++
> 4 files changed, 30 insertions(+), 1 deletion(-)
>
> diff --git a/builtin/blame.c b/builtin/blame.c
> index e982fb8..a219068 100644
> --- a/builtin/blame.c
> +++ b/builtin/blame.c
> @@ -2376,7 +2376,11 @@ static struct commit *fake_working_tree_commit(struct diff_options *opt,
> if (strbuf_read(&buf, 0, 0) < 0)
> die_errno("failed to read from stdin");
> }
> - convert_to_git(path, buf.buf, buf.len, &buf, 0);
> + if (convert_needs_conversion(path)) {
> + read_cache();
> + convert_to_git(path, buf.buf, buf.len, &buf, 0);
> + discard_cache();
> + }
> origin->file.ptr = buf.buf;
> origin->file.size = buf.len;
> pretend_sha1_file(buf.buf, buf.len, OBJ_BLOB, origin->blob_sha1);
> diff --git a/convert.c b/convert.c
> index 4ed5d89..02c50da 100644
> --- a/convert.c
> +++ b/convert.c
> @@ -903,6 +903,16 @@ const char *get_convert_attr_ascii(const char *path)
> return "";
> }
>
> +int convert_needs_conversion(const char *path)
> +{
> + struct conv_attrs ca;
> +
> + convert_attrs(&ca, path);
> + if (ca.drv || ca.ident || ca.crlf_action != CRLF_BINARY)
> + return 1;
> + return 0;
> +}
> +
> int convert_to_git(const char *path, const char *src, size_t len,
> struct strbuf *dst, enum safe_crlf checksafe)
> {
> diff --git a/convert.h b/convert.h
> index ccf436b..ffd9c32 100644
> --- a/convert.h
> +++ b/convert.h
> @@ -35,6 +35,7 @@ extern enum eol core_eol;
> extern const char *get_cached_convert_stats_ascii(const char *path);
> extern const char *get_wt_convert_stats_ascii(const char *path);
> extern const char *get_convert_attr_ascii(const char *path);
> +int convert_needs_conversion(const char *path);
>
> /* returns 1 if *dst was used */
> extern int convert_to_git(const char *path, const char *src, size_t len,
> diff --git a/t/t8003-blame-corner-cases.sh b/t/t8003-blame-corner-cases.sh
> index 6568429..a9b266f 100755
> --- a/t/t8003-blame-corner-cases.sh
> +++ b/t/t8003-blame-corner-cases.sh
> @@ -212,4 +212,18 @@ test_expect_success 'blame file with CRLF attributes text' '
> grep "A U Thor" actual
> '
>
> +test_expect_success 'blame file with CRLF core.autocrlf=true' '
> + git config core.autocrlf false &&
> + printf "testcase\r\n" >crlfinrepo &&
> + >.gitattributes &&
> + git add crlfinrepo &&
> + git commit -m "add crlfinrepo" &&
> + git config core.autocrlf true &&
> + mv crlfinrepo tmp &&
> + git checkout crlfinrepo &&
> + rm tmp &&
> + git blame crlfinrepo >actual &&
> + grep "A U Thor" actual
> +'
> +
> test_done
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v2 6/7] correct blame for files commited with CRLF
2016-04-01 22:29 ` Junio C Hamano
@ 2016-04-03 9:29 ` Torsten Bögershausen
0 siblings, 0 replies; 126+ messages in thread
From: Torsten Bögershausen @ 2016-04-03 9:29 UTC (permalink / raw)
To: Junio C Hamano, tboegi; +Cc: git
Thanks for all the comments.
I just reallized that t6038 is broken, which I didn't notice before :-(
Please feel free to kick out
tb/safe-crlf-output-fix from pu,
until I have looked into the breakage and found a fix.
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH v1] correct blame for files commited with CRLF
2016-03-07 22:34 ` Junio C Hamano
` (13 preceding siblings ...)
2016-04-01 16:08 ` [PATCH v2 7/7] convert.c: more safer crlf handling with text attribute tboegi
@ 2016-04-05 19:23 ` tboegi
2016-04-05 20:57 ` Junio C Hamano
2016-04-05 21:12 ` Junio C Hamano
2016-04-19 13:24 ` [PATCH v5 1/4] t0027: Make more reliable tboegi
` (50 subsequent siblings)
65 siblings, 2 replies; 126+ messages in thread
From: tboegi @ 2016-04-05 19:23 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
git blame reports lines as not "Not Committed Yet" when they have
CRLF in the index, CRLF in the worktree and core.autocrlf is true.
Since commit c48053 "new safer autocrlf handling", files that have CRLF
in the index are not normalized at commit when core.autocrl is set.
Add a call to read_cache() early in fake_working_tree_commit(),
before calling convert_to_git().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
This fix is completely independent of the rest of the series,
so break out 6/7 from tb/safe-crlf-output.
The rest of the series will be send in a couple of days, some
rework is needed.
builtin/blame.c | 1 +
t/t8003-blame-corner-cases.sh | 14 ++++++++++++++
2 files changed, 15 insertions(+)
diff --git a/builtin/blame.c b/builtin/blame.c
index e982fb8..21f42b0 100644
--- a/builtin/blame.c
+++ b/builtin/blame.c
@@ -2307,6 +2307,7 @@ static struct commit *fake_working_tree_commit(struct diff_options *opt,
unsigned mode;
struct strbuf msg = STRBUF_INIT;
+ read_cache();
time(&now);
commit = alloc_commit_node();
commit->object.parsed = 1;
diff --git a/t/t8003-blame-corner-cases.sh b/t/t8003-blame-corner-cases.sh
index 6568429..a9b266f 100755
--- a/t/t8003-blame-corner-cases.sh
+++ b/t/t8003-blame-corner-cases.sh
@@ -212,4 +212,18 @@ test_expect_success 'blame file with CRLF attributes text' '
grep "A U Thor" actual
'
+test_expect_success 'blame file with CRLF core.autocrlf=true' '
+ git config core.autocrlf false &&
+ printf "testcase\r\n" >crlfinrepo &&
+ >.gitattributes &&
+ git add crlfinrepo &&
+ git commit -m "add crlfinrepo" &&
+ git config core.autocrlf true &&
+ mv crlfinrepo tmp &&
+ git checkout crlfinrepo &&
+ rm tmp &&
+ git blame crlfinrepo >actual &&
+ grep "A U Thor" actual
+'
+
test_done
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH v1] correct blame for files commited with CRLF
2016-04-05 19:23 ` [PATCH v1] correct blame for files commited with CRLF tboegi
@ 2016-04-05 20:57 ` Junio C Hamano
2016-04-05 21:12 ` Junio C Hamano
1 sibling, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-04-05 20:57 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> This fix is completely independent of the rest of the series,
> so break out 6/7 from tb/safe-crlf-output.
Sounds sensible. It is somewhat sad and strange that we need to
rely on what is in the index to show the current working tree state,
but this makes the things more consistent.
Will queue. Thanks.
> builtin/blame.c | 1 +
> t/t8003-blame-corner-cases.sh | 14 ++++++++++++++
> 2 files changed, 15 insertions(+)
>
> diff --git a/builtin/blame.c b/builtin/blame.c
> index e982fb8..21f42b0 100644
> --- a/builtin/blame.c
> +++ b/builtin/blame.c
> @@ -2307,6 +2307,7 @@ static struct commit *fake_working_tree_commit(struct diff_options *opt,
> unsigned mode;
> struct strbuf msg = STRBUF_INIT;
>
> + read_cache();
> time(&now);
> commit = alloc_commit_node();
> commit->object.parsed = 1;
> diff --git a/t/t8003-blame-corner-cases.sh b/t/t8003-blame-corner-cases.sh
> index 6568429..a9b266f 100755
> --- a/t/t8003-blame-corner-cases.sh
> +++ b/t/t8003-blame-corner-cases.sh
> @@ -212,4 +212,18 @@ test_expect_success 'blame file with CRLF attributes text' '
> grep "A U Thor" actual
> '
>
> +test_expect_success 'blame file with CRLF core.autocrlf=true' '
> + git config core.autocrlf false &&
> + printf "testcase\r\n" >crlfinrepo &&
> + >.gitattributes &&
> + git add crlfinrepo &&
> + git commit -m "add crlfinrepo" &&
> + git config core.autocrlf true &&
> + mv crlfinrepo tmp &&
> + git checkout crlfinrepo &&
> + rm tmp &&
> + git blame crlfinrepo >actual &&
> + grep "A U Thor" actual
> +'
> +
> test_done
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1] correct blame for files commited with CRLF
2016-04-05 19:23 ` [PATCH v1] correct blame for files commited with CRLF tboegi
2016-04-05 20:57 ` Junio C Hamano
@ 2016-04-05 21:12 ` Junio C Hamano
2016-04-06 4:17 ` Torsten Bögershausen
1 sibling, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-04-05 21:12 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> + git config core.autocrlf true &&
> + mv crlfinrepo tmp &&
> + git checkout crlfinrepo &&
> + rm tmp &&
Why not just "rm -f crlfinrepo" and "git checkout crlfinrepo"?
> + git blame crlfinrepo >actual &&
> + grep "A U Thor" actual
> +'
> +
> test_done
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v1] correct blame for files commited with CRLF
2016-04-05 21:12 ` Junio C Hamano
@ 2016-04-06 4:17 ` Torsten Bögershausen
0 siblings, 0 replies; 126+ messages in thread
From: Torsten Bögershausen @ 2016-04-06 4:17 UTC (permalink / raw)
To: Junio C Hamano, tboegi; +Cc: git
On 05.04.16 23:12, Junio C Hamano wrote:
> tboegi@web.de writes:
>
>> + git config core.autocrlf true &&
>> + mv crlfinrepo tmp &&
>> + git checkout crlfinrepo &&
>> + rm tmp &&
>
> Why not just "rm -f crlfinrepo" and "git checkout crlfinrepo"?
The intention was to get a new inode number, which marks the file
in the working tree as modified, regardless of mtime.
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH v5 1/4] t0027: Make more reliable
2016-03-07 22:34 ` Junio C Hamano
` (14 preceding siblings ...)
2016-04-05 19:23 ` [PATCH v1] correct blame for files commited with CRLF tboegi
@ 2016-04-19 13:24 ` tboegi
2016-04-19 13:26 ` [PATCH v5 2/4] convert: allow core.autocrlf=input and core.eol=crlf tboegi
` (49 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-19 13:24 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Make the commit_chk_wrnNNO test in t0027 more reliable:
When the attributes of a commited file are changed and the file is otherwise
unchanged, Git may not detect that the next commit may need to treat the
file as changed.
This happens when lstat() doesn't detect a change, since neither inode,
mtime nor size are changed.
Add a singe "Z" character to change the file size.
Ignore it when comparing the files later.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Changes against the last round:
- Add this commit, since t0027 become shaky
- Add bugfix in 4/4
- Remove the non-normalizing changes, they will be part of a different
series. Mainly because t6038 needs improvements, and ce_compare_data()
in read_cache.c needs to learn to run convert_to_git()
t/t0027-auto-crlf.sh | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index f33962b..9fe539b 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -12,7 +12,7 @@ fi
compare_files () {
tr '\015\000' QN <"$1" >"$1".expect &&
- tr '\015\000' QN <"$2" >"$2".actual &&
+ tr '\015\000' QN <"$2" | tr -d 'Z' >"$2".actual &&
test_cmp "$1".expect "$2".actual &&
rm "$1".expect "$2".actual
}
@@ -114,6 +114,7 @@ commit_chk_wrnNNO () {
do
fname=${pfx}_$f.txt &&
cp $f $fname &&
+ printf Z >>"$fname" &&
git -c core.autocrlf=$crlf add $fname 2>/dev/null &&
git -c core.autocrlf=$crlf commit -m "commit_$fname" $fname >"${pfx}_$f.err" 2>&1
done
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v5 2/4] convert: allow core.autocrlf=input and core.eol=crlf
2016-03-07 22:34 ` Junio C Hamano
` (15 preceding siblings ...)
2016-04-19 13:24 ` [PATCH v5 1/4] t0027: Make more reliable tboegi
@ 2016-04-19 13:26 ` tboegi
2016-04-19 13:26 ` [PATCH v5 3/4] t0027: test cases for combined attributes tboegi
` (48 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-19 13:26 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Even though the configuration parser errors out when core.autocrlf
is set to 'input' when core.eol is set to 'crlf', there is no need
to do so, because the core.autocrlf setting trumps core.eol.
Allow all combinations of core.crlf and core.eol and document
that core.autocrlf overrides core.eol.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 6 +++---
config.c | 4 ----
2 files changed, 3 insertions(+), 7 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 42d2b50..155f988 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -337,9 +337,9 @@ core.quotePath::
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
+ files that have the `text` property set when core.autocrlf is false.
+ 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.
diff --git a/config.c b/config.c
index 4c92699..c8ac9c2 100644
--- a/config.c
+++ b/config.c
@@ -803,8 +803,6 @@ static int git_default_core_config(const char *var, const char *value)
if (!strcmp(var, "core.autocrlf")) {
if (value && !strcasecmp(value, "input")) {
- if (core_eol == EOL_CRLF)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
auto_crlf = AUTO_CRLF_INPUT;
return 0;
}
@@ -830,8 +828,6 @@ static int git_default_core_config(const char *var, const char *value)
core_eol = EOL_NATIVE;
else
core_eol = EOL_UNSET;
- if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
return 0;
}
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v5 3/4] t0027: test cases for combined attributes
2016-03-07 22:34 ` Junio C Hamano
` (16 preceding siblings ...)
2016-04-19 13:26 ` [PATCH v5 2/4] convert: allow core.autocrlf=input and core.eol=crlf tboegi
@ 2016-04-19 13:26 ` tboegi
2016-04-19 21:32 ` Junio C Hamano
2016-04-19 13:26 ` [PATCH v5 4/4] convert.c: ident + core.autocrlf didn't work tboegi
` (47 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-19 13:26 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Add more test cases for the not normalized files ("NNO"). The
"text" attribute is most important, use it as the first parameter.
"ident", if set, is the second paramater followed by the eol
attribute. The eol attribute overrides core.autocrlf, which
overrides core.eol.
indent is not yet uses, this will be done in the next commit.
Use loops to test more combinations of attributes, like
"* text eol=crlf" or especially "*text=auto eol=crlf".
Currently "* text=auto eol=lf" does the same as "* text eol=lf",
as the eol attribute overrides "text=auto", this will change in
future.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t0027-auto-crlf.sh | 298 ++++++++++++++++++++++-----------------------------
1 file changed, 129 insertions(+), 169 deletions(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 9fe539b..fd5e326 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -52,14 +52,17 @@ create_gitattributes () {
create_NNO_files () {
for crlf in false true input
do
- for attr in "" auto text -text lf crlf
+ for attr in "" auto text -text
do
- pfx=NNO_${crlf}_attr_${attr} &&
- cp CRLF_mix_LF ${pfx}_LF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
- cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ for aeol in "" lf crlf
+ do
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ cp CRLF_mix_LF ${pfx}_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ done
done
done
}
@@ -100,16 +103,17 @@ commit_check_warn () {
}
commit_chk_wrnNNO () {
- crlf=$1
- attr=$2
- lfwarn=$3
- crlfwarn=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfwarn=$1 ; shift
+ crlfwarn=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
#Commit files on top of existing file
- create_gitattributes "$attr" &&
+ create_gitattributes "$attr" $aeol &&
for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
do
fname=${pfx}_$f.txt &&
@@ -122,19 +126,19 @@ commit_chk_wrnNNO () {
test_expect_success "commit NNO files crlf=$crlf attr=$attr LF" '
check_warning "$lfwarn" ${pfx}_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF" '
check_warning "$crlfwarn" ${pfx}_CRLF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_mix_LF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_mix_LF" '
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr LF_mix_cr" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf LF_mix_cr" '
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_nul" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_nul" '
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
'
}
@@ -163,6 +167,7 @@ stats_ascii () {
# contruct the attr/ returned by git ls-files --eol
# Take none (=empty), one or two args
+# convert.c: eol=XX overrides text=auto
attr_ascii () {
case $1,$2 in
-text,*) echo "-text" ;;
@@ -170,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text=auto eol=lf" ;;
- auto,crlf) echo "text=auto eol=crlf" ;;
+ auto,lf) echo "text eol=lf" ;;
+ auto,crlf) echo "text eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -196,28 +201,29 @@ check_files_in_repo () {
}
check_in_repo_NNO () {
- crlf=$1
- attr=$2
- lfname=$3
- crlfname=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}_
- test_expect_success "compare_files $lfname ${pfx}LF.txt" '
- compare_files $lfname ${pfx}LF.txt
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfname=$1 ; shift
+ crlfname=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ test_expect_success "compare_files $lfname ${pfx}_LF.txt" '
+ compare_files $lfname ${pfx}_LF.txt
'
- test_expect_success "compare_files $crlfname ${pfx}CRLF.txt" '
- compare_files $crlfname ${pfx}CRLF.txt
+ test_expect_success "compare_files $crlfname ${pfx}_CRLF.txt" '
+ compare_files $crlfname ${pfx}_CRLF.txt
'
- test_expect_success "compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt" '
- compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt
+ test_expect_success "compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt" '
+ compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt
'
- test_expect_success "compare_files $lfmixcr ${pfx}LF_mix_CR.txt" '
- compare_files $lfmixcr ${pfx}LF_mix_CR.txt
+ test_expect_success "compare_files $lfmixcr ${pfx}_LF_mix_CR.txt" '
+ compare_files $lfmixcr ${pfx}_LF_mix_CR.txt
'
- test_expect_success "compare_files $crlfnul ${pfx}CRLF_nul.txt" '
- compare_files $crlfnul ${pfx}CRLF_nul.txt
+ test_expect_success "compare_files $crlfnul ${pfx}_CRLF_nul.txt" '
+ compare_files $crlfnul ${pfx}_CRLF_nul.txt
'
}
@@ -232,7 +238,7 @@ checkout_files () {
lfmixcrlf=$1 ; shift
lfmixcr=$1 ; shift
crlfnul=$1 ; shift
- create_gitattributes "$attr" "$ident" &&
+ create_gitattributes "$attr" $ident $aeol &&
git config core.autocrlf $crlf &&
pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
@@ -245,7 +251,7 @@ checkout_files () {
fi
done
- test_expect_success "ls-files --eol attr=$attr $ident $aeol core.autocrlf=$crlf core.eol=$ceol" '
+ test_expect_success "ls-files --eol attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol" '
test_when_finished "rm expect actual" &&
sort <<-EOF >expect &&
i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
@@ -260,19 +266,19 @@ checkout_files () {
sort >actual &&
test_cmp expect actual
'
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
compare_ws_file $pfx $lfname crlf_false_attr__LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
compare_ws_file $pfx $crlfname crlf_false_attr__CRLF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
compare_ws_file $pfx $lfmixcrlf crlf_false_attr__CRLF_mix_LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
compare_ws_file $pfx $lfmixcr crlf_false_attr__LF_mix_CR.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
compare_ws_file $pfx $crlfnul crlf_false_attr__LF_nul.txt
"
}
@@ -386,31 +392,31 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
-commit_chk_wrnNNO false "" "" "" "" "" ""
-commit_chk_wrnNNO true "" "LF_CRLF" "" "" "" ""
-commit_chk_wrnNNO input "" "" "" "" "" ""
-
+# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+commit_chk_wrnNNO "" "" false "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO false "auto" "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO true "auto" "LF_CRLF" "" "LF_CRLF" "" ""
-commit_chk_wrnNNO input "auto" "" "CRLF_LF" "CRLF_LF" "" ""
+commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-commit_chk_wrnNNO false "text" "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO true "text" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "text" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-
-commit_chk_wrnNNO false "-text" "" "" "" "" ""
-commit_chk_wrnNNO true "-text" "" "" "" "" ""
-commit_chk_wrnNNO input "-text" "" "" "" "" ""
-
-commit_chk_wrnNNO false "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO true "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO input "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
+for crlf in true false input
+do
+ commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+done
-commit_chk_wrnNNO false "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO true "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
test_expect_success 'create files cleanup' '
rm -f *.txt &&
@@ -441,24 +447,20 @@ test_expect_success 'commit -text' '
check_files_in_repo input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
'
-# attr LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
-check_in_repo_NNO false "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "auto" LF LF LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO true "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO input "text" LF LF LF LF_mix_CR LF_nul
-
-check_in_repo_NNO false "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-
+for crlf in true false input
+do
+ # attr aeol LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
+ check_in_repo_NNO "" "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+done
################################################################################
# Check how files in the repo are changed when they are checked out
# How to read the table below:
@@ -490,89 +492,47 @@ LFNUL=LF_nul
fi
export CRLF_MIX_LF_CR MIX NL
-checkout_files "" "" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true "" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true crlf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true lf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true native CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true "" CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true lf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true native CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-
-for id in "" ident;
+# Same handling with and without ident
+for id in ""
do
- checkout_files "crlf" "$id" "" false "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "lf" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "-text" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ for ceol in lf crlf native
+ do
+ for crlf in true false input
+ do
+ # -text overrides core.autocrlf and core.eol
+ # text and eol=crlf or eol=lf override core.autocrlf and core.eol
+ checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # currently the same as text, eol=XXX
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+
+ # core.autocrlf false, different core.eol
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # core.autocrlf true
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf = true overrides core.eol
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # text: core.autocrlf = input overrides core.eol
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text=auto + eol=XXX
+ done
+ # text: core.autocrlf=false uses core.eol
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ # auto: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v5 4/4] convert.c: ident + core.autocrlf didn't work
2016-03-07 22:34 ` Junio C Hamano
` (17 preceding siblings ...)
2016-04-19 13:26 ` [PATCH v5 3/4] t0027: test cases for combined attributes tboegi
@ 2016-04-19 13:26 ` tboegi
2016-04-20 22:27 ` Junio C Hamano
2016-04-22 14:38 ` [PATCH v6 01/10] t0027: Make more reliable tboegi
` (46 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-19 13:26 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When the ident attributes is set, get_stream_filter() did not obey
core.autocrlf=true, and the file was checked out with LF.
Change the rule when a streaming filter can be used:
- if an external filter is specified, don't use a stream filter.
- if the worktree eol is CRLF and "auto" is active, don't use a stream filter.
- Otherwise the stream filter can be used.
Add test cases in t0027.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 18 ++++++------------
t/t0027-auto-crlf.sh | 2 +-
2 files changed, 7 insertions(+), 13 deletions(-)
diff --git a/convert.c b/convert.c
index f524b8d..e8b0187 100644
--- a/convert.c
+++ b/convert.c
@@ -1380,27 +1380,21 @@ static struct stream_filter *ident_filter(const unsigned char *sha1)
struct stream_filter *get_stream_filter(const char *path, const unsigned char *sha1)
{
struct conv_attrs ca;
- enum crlf_action crlf_action;
struct stream_filter *filter = NULL;
convert_attrs(&ca, path);
-
if (ca.drv && (ca.drv->smudge || ca.drv->clean))
- return filter;
+ return NULL;
if (ca.ident)
filter = ident_filter(sha1);
- crlf_action = ca.crlf_action;
-
- if ((crlf_action == CRLF_BINARY) ||
- crlf_action == CRLF_AUTO_INPUT ||
- (crlf_action == CRLF_TEXT_INPUT))
- filter = cascade_filter(filter, &null_filter_singleton);
-
- else if (output_eol(crlf_action) == EOL_CRLF &&
- !(crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_CRLF))
+ if (output_eol(ca.crlf_action) == EOL_CRLF) {
+ if (ca.crlf_action == CRLF_AUTO || ca.crlf_action == CRLF_AUTO_CRLF)
+ return NULL;
filter = cascade_filter(filter, lf_to_crlf_filter());
+ } else
+ filter = cascade_filter(filter, &null_filter_singleton);
return filter;
}
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index fd5e326..9372589 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -493,7 +493,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH v5 3/4] t0027: test cases for combined attributes
2016-04-19 13:26 ` [PATCH v5 3/4] t0027: test cases for combined attributes tboegi
@ 2016-04-19 21:32 ` Junio C Hamano
2016-04-20 15:52 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-04-19 21:32 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> Add more test cases for the not normalized files ("NNO"). The
> "text" attribute is most important, use it as the first parameter.
> "ident", if set, is the second paramater followed by the eol
> attribute. The eol attribute overrides core.autocrlf, which
> overrides core.eol.
> indent is not yet uses, this will be done in the next commit.
>
> Use loops to test more combinations of attributes, like
> "* text eol=crlf" or especially "*text=auto eol=crlf".
>
> Currently "* text=auto eol=lf" does the same as "* text eol=lf",
> as the eol attribute overrides "text=auto", this will change in
> future.
Will change in future in what way? In patch 5/4?
>
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
> ---
> t/t0027-auto-crlf.sh | 298 ++++++++++++++++++++++-----------------------------
> 1 file changed, 129 insertions(+), 169 deletions(-)
>
> diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
> index 9fe539b..fd5e326 100755
> --- a/t/t0027-auto-crlf.sh
> +++ b/t/t0027-auto-crlf.sh
> @@ -52,14 +52,17 @@ create_gitattributes () {
> create_NNO_files () {
> for crlf in false true input
> do
> - for attr in "" auto text -text lf crlf
> + for attr in "" auto text -text
> do
> - pfx=NNO_${crlf}_attr_${attr} &&
> - cp CRLF_mix_LF ${pfx}_LF.txt &&
> - cp CRLF_mix_LF ${pfx}_CRLF.txt &&
> - cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
> - cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
> - cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
> + for aeol in "" lf crlf
> + do
> + pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
> + cp CRLF_mix_LF ${pfx}_LF.txt &&
> + cp CRLF_mix_LF ${pfx}_CRLF.txt &&
> + cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
> + cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
> + cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
> + done
> done
> done
> }
> @@ -100,16 +103,17 @@ commit_check_warn () {
> }
>
> commit_chk_wrnNNO () {
> - crlf=$1
> - attr=$2
> - lfwarn=$3
> - crlfwarn=$4
> - lfmixcrlf=$5
> - lfmixcr=$6
> - crlfnul=$7
> - pfx=NNO_${crlf}_attr_${attr}
> + attr=$1 ; shift
> + aeol=$1 ; shift
> + crlf=$1 ; shift
> + lfwarn=$1 ; shift
> + crlfwarn=$1 ; shift
> + lfmixcrlf=$1 ; shift
> + lfmixcr=$1 ; shift
> + crlfnul=$1 ; shift
> + pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
> #Commit files on top of existing file
> - create_gitattributes "$attr" &&
> + create_gitattributes "$attr" $aeol &&
> for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> do
> fname=${pfx}_$f.txt &&
> @@ -122,19 +126,19 @@ commit_chk_wrnNNO () {
> test_expect_success "commit NNO files crlf=$crlf attr=$attr LF" '
> check_warning "$lfwarn" ${pfx}_LF.err
> '
> - test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF" '
> + test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF" '
> check_warning "$crlfwarn" ${pfx}_CRLF.err
> '
>
> - test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_mix_LF" '
> + test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_mix_LF" '
> check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
> '
>
> - test_expect_success "commit NNO files crlf=$crlf attr=$attr LF_mix_cr" '
> + test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf LF_mix_cr" '
> check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
> '
>
> - test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_nul" '
> + test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_nul" '
> check_warning "$crlfnul" ${pfx}_CRLF_nul.err
> '
> }
> @@ -163,6 +167,7 @@ stats_ascii () {
>
> # contruct the attr/ returned by git ls-files --eol
> # Take none (=empty), one or two args
> +# convert.c: eol=XX overrides text=auto
> attr_ascii () {
> case $1,$2 in
> -text,*) echo "-text" ;;
> @@ -170,8 +175,8 @@ attr_ascii () {
> text,lf) echo "text eol=lf" ;;
> text,crlf) echo "text eol=crlf" ;;
> auto,) echo "text=auto" ;;
> - auto,lf) echo "text=auto eol=lf" ;;
> - auto,crlf) echo "text=auto eol=crlf" ;;
> + auto,lf) echo "text eol=lf" ;;
> + auto,crlf) echo "text eol=crlf" ;;
> lf,) echo "text eol=lf" ;;
> crlf,) echo "text eol=crlf" ;;
> ,) echo "" ;;
> @@ -196,28 +201,29 @@ check_files_in_repo () {
> }
>
> check_in_repo_NNO () {
> - crlf=$1
> - attr=$2
> - lfname=$3
> - crlfname=$4
> - lfmixcrlf=$5
> - lfmixcr=$6
> - crlfnul=$7
> - pfx=NNO_${crlf}_attr_${attr}_
> - test_expect_success "compare_files $lfname ${pfx}LF.txt" '
> - compare_files $lfname ${pfx}LF.txt
> + attr=$1 ; shift
> + aeol=$1 ; shift
> + crlf=$1 ; shift
> + lfname=$1 ; shift
> + crlfname=$1 ; shift
> + lfmixcrlf=$1 ; shift
> + lfmixcr=$1 ; shift
> + crlfnul=$1 ; shift
> + pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
> + test_expect_success "compare_files $lfname ${pfx}_LF.txt" '
> + compare_files $lfname ${pfx}_LF.txt
> '
> - test_expect_success "compare_files $crlfname ${pfx}CRLF.txt" '
> - compare_files $crlfname ${pfx}CRLF.txt
> + test_expect_success "compare_files $crlfname ${pfx}_CRLF.txt" '
> + compare_files $crlfname ${pfx}_CRLF.txt
> '
> - test_expect_success "compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt" '
> - compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt
> + test_expect_success "compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt" '
> + compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt
> '
> - test_expect_success "compare_files $lfmixcr ${pfx}LF_mix_CR.txt" '
> - compare_files $lfmixcr ${pfx}LF_mix_CR.txt
> + test_expect_success "compare_files $lfmixcr ${pfx}_LF_mix_CR.txt" '
> + compare_files $lfmixcr ${pfx}_LF_mix_CR.txt
> '
> - test_expect_success "compare_files $crlfnul ${pfx}CRLF_nul.txt" '
> - compare_files $crlfnul ${pfx}CRLF_nul.txt
> + test_expect_success "compare_files $crlfnul ${pfx}_CRLF_nul.txt" '
> + compare_files $crlfnul ${pfx}_CRLF_nul.txt
> '
> }
>
> @@ -232,7 +238,7 @@ checkout_files () {
> lfmixcrlf=$1 ; shift
> lfmixcr=$1 ; shift
> crlfnul=$1 ; shift
> - create_gitattributes "$attr" "$ident" &&
> + create_gitattributes "$attr" $ident $aeol &&
> git config core.autocrlf $crlf &&
> pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
> for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
> @@ -245,7 +251,7 @@ checkout_files () {
> fi
> done
>
> - test_expect_success "ls-files --eol attr=$attr $ident $aeol core.autocrlf=$crlf core.eol=$ceol" '
> + test_expect_success "ls-files --eol attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol" '
> test_when_finished "rm expect actual" &&
> sort <<-EOF >expect &&
> i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
> @@ -260,19 +266,19 @@ checkout_files () {
> sort >actual &&
> test_cmp expect actual
> '
> - test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
> + test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
> compare_ws_file $pfx $lfname crlf_false_attr__LF.txt
> "
> - test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
> + test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
> compare_ws_file $pfx $crlfname crlf_false_attr__CRLF.txt
> "
> - test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
> + test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
> compare_ws_file $pfx $lfmixcrlf crlf_false_attr__CRLF_mix_LF.txt
> "
> - test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
> + test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
> compare_ws_file $pfx $lfmixcr crlf_false_attr__LF_mix_CR.txt
> "
> - test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
> + test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
> compare_ws_file $pfx $crlfnul crlf_false_attr__LF_nul.txt
> "
> }
> @@ -386,31 +392,31 @@ test_expect_success 'commit files attr=crlf' '
> commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
> '
>
> -# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
> -commit_chk_wrnNNO false "" "" "" "" "" ""
> -commit_chk_wrnNNO true "" "LF_CRLF" "" "" "" ""
> -commit_chk_wrnNNO input "" "" "" "" "" ""
> -
> +# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
> +commit_chk_wrnNNO "" "" false "" "" "" "" ""
> +commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
> +commit_chk_wrnNNO "" "" input "" "" "" "" ""
>
> -commit_chk_wrnNNO false "auto" "$WILC" "$WICL" "$WAMIX" "" ""
> -commit_chk_wrnNNO true "auto" "LF_CRLF" "" "LF_CRLF" "" ""
> -commit_chk_wrnNNO input "auto" "" "CRLF_LF" "CRLF_LF" "" ""
> +commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
> +commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
> +commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
>
> -commit_chk_wrnNNO false "text" "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
> -commit_chk_wrnNNO true "text" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
> -commit_chk_wrnNNO input "text" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
> -
> -commit_chk_wrnNNO false "-text" "" "" "" "" ""
> -commit_chk_wrnNNO true "-text" "" "" "" "" ""
> -commit_chk_wrnNNO input "-text" "" "" "" "" ""
> -
> -commit_chk_wrnNNO false "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
> -commit_chk_wrnNNO true "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
> -commit_chk_wrnNNO input "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
> +for crlf in true false input
> +do
> + commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
> + commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
> + commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
> + commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
> + commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
> + commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
> + commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
> + commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
> + commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
> +done
>
> -commit_chk_wrnNNO false "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
> -commit_chk_wrnNNO true "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
> -commit_chk_wrnNNO input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
> +commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
> +commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
> +commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
>
> test_expect_success 'create files cleanup' '
> rm -f *.txt &&
> @@ -441,24 +447,20 @@ test_expect_success 'commit -text' '
> check_files_in_repo input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> '
>
> -# attr LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
> -check_in_repo_NNO false "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> -check_in_repo_NNO true "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> -check_in_repo_NNO input "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> -
> -check_in_repo_NNO false "auto" LF LF LF LF_mix_CR CRLF_nul
> -check_in_repo_NNO true "auto" LF LF LF LF_mix_CR CRLF_nul
> -check_in_repo_NNO input "auto" LF LF LF LF_mix_CR CRLF_nul
> -
> -check_in_repo_NNO false "text" LF LF LF LF_mix_CR LF_nul
> -check_in_repo_NNO true "text" LF LF LF LF_mix_CR LF_nul
> -check_in_repo_NNO input "text" LF LF LF LF_mix_CR LF_nul
> -
> -check_in_repo_NNO false "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> -check_in_repo_NNO true "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> -check_in_repo_NNO input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> -
> -
> +for crlf in true false input
> +do
> + # attr aeol LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
> + check_in_repo_NNO "" "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> + check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> + check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> + check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
> + check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
> + check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
> + check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
> + check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
> + check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
> + check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
> +done
> ################################################################################
> # Check how files in the repo are changed when they are checked out
> # How to read the table below:
> @@ -490,89 +492,47 @@ LFNUL=LF_nul
> fi
> export CRLF_MIX_LF_CR MIX NL
>
> -checkout_files "" "" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" "" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" "" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" "" "" true "" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" "" "" true crlf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" "" "" true lf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" "" "" true native CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" false crlf CRLF CRLF CRLF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" true "" CRLF CRLF CRLF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" true crlf CRLF CRLF CRLF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" true lf CRLF CRLF CRLF LF_mix_CR LF_nul
> -checkout_files "auto" "" "" true native CRLF CRLF CRLF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -checkout_files "auto" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> -
> -for id in "" ident;
> +# Same handling with and without ident
> +for id in ""
> do
> - checkout_files "crlf" "$id" "" false "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "crlf" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "crlf" "$id" "" false lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "crlf" "$id" "" false native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "crlf" "$id" "" input "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "crlf" "$id" "" input lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "crlf" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "crlf" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "crlf" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "crlf" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "lf" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "lf" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "lf" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "lf" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "lf" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "lf" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "lf" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "lf" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "lf" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "lf" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
> - checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
> - checkout_files "text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "text" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "text" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "text" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "text" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> - checkout_files "-text" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "-text" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "-text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "-text" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "-text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "-text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "-text" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "-text" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "-text" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> - checkout_files "-text" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + for ceol in lf crlf native
> + do
> + for crlf in true false input
> + do
> + # -text overrides core.autocrlf and core.eol
> + # text and eol=crlf or eol=lf override core.autocrlf and core.eol
> + checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + # text
> + checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> + # currently the same as text, eol=XXX
> + checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> + done
> +
> + # core.autocrlf false, different core.eol
> + checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + # core.autocrlf true
> + checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + # text: core.autocrlf = true overrides core.eol
> + checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
> + checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> + # text: core.autocrlf = input overrides core.eol
> + checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + # text=auto + eol=XXX
> + done
> + # text: core.autocrlf=false uses core.eol
> + checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
> + checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
> + # text: core.autocrlf=false and core.eol unset(or native) uses native eol
> + checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
> + checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
> + # auto: core.autocrlf=false and core.eol unset(or native) uses native eol
> + checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
> + checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
> done
>
> # Should be the last test case: remove some files from the worktree
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v5 3/4] t0027: test cases for combined attributes
2016-04-19 21:32 ` Junio C Hamano
@ 2016-04-20 15:52 ` Torsten Bögershausen
0 siblings, 0 replies; 126+ messages in thread
From: Torsten Bögershausen @ 2016-04-20 15:52 UTC (permalink / raw)
To: Junio C Hamano, tboegi; +Cc: git
>> Currently "* text=auto eol=lf" does the same as "* text eol=lf",
>> as the eol attribute overrides "text=auto", this will change in
>> future.
> Will change in future in what way? In patch 5/4?
>
>
Yes, kind of.
I'm fighting to get the test passed under Windows,
and if this 4/4 could make it into pu, I don't need to
resend all of it.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v5 4/4] convert.c: ident + core.autocrlf didn't work
2016-04-19 13:26 ` [PATCH v5 4/4] convert.c: ident + core.autocrlf didn't work tboegi
@ 2016-04-20 22:27 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-04-20 22:27 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> if (ca.drv && (ca.drv->smudge || ca.drv->clean))
> - return filter;
> + return NULL;
>
> if (ca.ident)
> filter = ident_filter(sha1);
We allocated an ident-filter here...
> - crlf_action = ca.crlf_action;
> -
> - if ((crlf_action == CRLF_BINARY) ||
> - crlf_action == CRLF_AUTO_INPUT ||
> - (crlf_action == CRLF_TEXT_INPUT))
> - filter = cascade_filter(filter, &null_filter_singleton);
> -
> - else if (output_eol(crlf_action) == EOL_CRLF &&
> - !(crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_CRLF))
> + if (output_eol(ca.crlf_action) == EOL_CRLF) {
> + if (ca.crlf_action == CRLF_AUTO || ca.crlf_action == CRLF_AUTO_CRLF)
> + return NULL;
and then by returning NULL, we lost it.
> filter = cascade_filter(filter, lf_to_crlf_filter());
> + } else
> + filter = cascade_filter(filter, &null_filter_singleton);
>
> return filter;
> }
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH v6 01/10] t0027: Make more reliable
2016-03-07 22:34 ` Junio C Hamano
` (18 preceding siblings ...)
2016-04-19 13:26 ` [PATCH v5 4/4] convert.c: ident + core.autocrlf didn't work tboegi
@ 2016-04-22 14:38 ` tboegi
2016-04-22 22:03 ` Junio C Hamano
2016-04-22 14:53 ` [PATCH v6 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
` (45 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-22 14:38 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Make the commit_chk_wrnNNO test in t0027 more reliable:
When the attributes of a commited file are changed and the file is otherwise
unchanged, Git may not detect that the next commit may need to treat the
file as changed.
This happens when lstat() doesn't detect a change, since neither inode,
mtime nor size are changed.
Add a singe "Z" character to change the file size.
Ignore it when comparing the files later.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Changes since v5:
- send the whole series, now 10/10
- Removed the "will change in future" in one commit msg
- Don't leak the filer in 4/10
t/t0027-auto-crlf.sh | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index f33962b..9fe539b 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -12,7 +12,7 @@ fi
compare_files () {
tr '\015\000' QN <"$1" >"$1".expect &&
- tr '\015\000' QN <"$2" >"$2".actual &&
+ tr '\015\000' QN <"$2" | tr -d 'Z' >"$2".actual &&
test_cmp "$1".expect "$2".actual &&
rm "$1".expect "$2".actual
}
@@ -114,6 +114,7 @@ commit_chk_wrnNNO () {
do
fname=${pfx}_$f.txt &&
cp $f $fname &&
+ printf Z >>"$fname" &&
git -c core.autocrlf=$crlf add $fname 2>/dev/null &&
git -c core.autocrlf=$crlf commit -m "commit_$fname" $fname >"${pfx}_$f.err" 2>&1
done
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6 02/10] convert: allow core.autocrlf=input and core.eol=crlf
2016-03-07 22:34 ` Junio C Hamano
` (19 preceding siblings ...)
2016-04-22 14:38 ` [PATCH v6 01/10] t0027: Make more reliable tboegi
@ 2016-04-22 14:53 ` tboegi
2016-04-22 14:53 ` [PATCH v6 03/10] t0027: test cases for combined attributes tboegi
` (44 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-22 14:53 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Even though the configuration parser errors out when core.autocrlf
is set to 'input' when core.eol is set to 'crlf', there is no need
to do so, because the core.autocrlf setting trumps core.eol.
Allow all combinations of core.crlf and core.eol and document
that core.autocrlf overrides core.eol.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 6 +++---
config.c | 4 ----
2 files changed, 3 insertions(+), 7 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 42d2b50..155f988 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -337,9 +337,9 @@ core.quotePath::
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
+ files that have the `text` property set when core.autocrlf is false.
+ 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.
diff --git a/config.c b/config.c
index 4c92699..c8ac9c2 100644
--- a/config.c
+++ b/config.c
@@ -803,8 +803,6 @@ static int git_default_core_config(const char *var, const char *value)
if (!strcmp(var, "core.autocrlf")) {
if (value && !strcasecmp(value, "input")) {
- if (core_eol == EOL_CRLF)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
auto_crlf = AUTO_CRLF_INPUT;
return 0;
}
@@ -830,8 +828,6 @@ static int git_default_core_config(const char *var, const char *value)
core_eol = EOL_NATIVE;
else
core_eol = EOL_UNSET;
- if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
return 0;
}
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6 03/10] t0027: test cases for combined attributes
2016-03-07 22:34 ` Junio C Hamano
` (20 preceding siblings ...)
2016-04-22 14:53 ` [PATCH v6 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
@ 2016-04-22 14:53 ` tboegi
2016-04-22 14:53 ` [PATCH v6 04/10] convert.c: ident + core.autocrlf didn't work tboegi
` (43 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-22 14:53 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Add more test cases for the not normalized files ("NNO"). The
"text" attribute is most important, use it as the first parameter.
"ident", if set, is the second paramater followed by the eol
attribute. The eol attribute overrides core.autocrlf, which
overrides core.eol.
indent is not yet uses, this will be done in the next commit.
Use loops to test more combinations of attributes, like
"* text eol=crlf" or especially "*text=auto eol=crlf".
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t0027-auto-crlf.sh | 298 ++++++++++++++++++++++-----------------------------
1 file changed, 129 insertions(+), 169 deletions(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 9fe539b..fd5e326 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -52,14 +52,17 @@ create_gitattributes () {
create_NNO_files () {
for crlf in false true input
do
- for attr in "" auto text -text lf crlf
+ for attr in "" auto text -text
do
- pfx=NNO_${crlf}_attr_${attr} &&
- cp CRLF_mix_LF ${pfx}_LF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
- cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ for aeol in "" lf crlf
+ do
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ cp CRLF_mix_LF ${pfx}_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ done
done
done
}
@@ -100,16 +103,17 @@ commit_check_warn () {
}
commit_chk_wrnNNO () {
- crlf=$1
- attr=$2
- lfwarn=$3
- crlfwarn=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfwarn=$1 ; shift
+ crlfwarn=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
#Commit files on top of existing file
- create_gitattributes "$attr" &&
+ create_gitattributes "$attr" $aeol &&
for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
do
fname=${pfx}_$f.txt &&
@@ -122,19 +126,19 @@ commit_chk_wrnNNO () {
test_expect_success "commit NNO files crlf=$crlf attr=$attr LF" '
check_warning "$lfwarn" ${pfx}_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF" '
check_warning "$crlfwarn" ${pfx}_CRLF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_mix_LF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_mix_LF" '
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr LF_mix_cr" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf LF_mix_cr" '
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_nul" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_nul" '
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
'
}
@@ -163,6 +167,7 @@ stats_ascii () {
# contruct the attr/ returned by git ls-files --eol
# Take none (=empty), one or two args
+# convert.c: eol=XX overrides text=auto
attr_ascii () {
case $1,$2 in
-text,*) echo "-text" ;;
@@ -170,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text=auto eol=lf" ;;
- auto,crlf) echo "text=auto eol=crlf" ;;
+ auto,lf) echo "text eol=lf" ;;
+ auto,crlf) echo "text eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -196,28 +201,29 @@ check_files_in_repo () {
}
check_in_repo_NNO () {
- crlf=$1
- attr=$2
- lfname=$3
- crlfname=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}_
- test_expect_success "compare_files $lfname ${pfx}LF.txt" '
- compare_files $lfname ${pfx}LF.txt
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfname=$1 ; shift
+ crlfname=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ test_expect_success "compare_files $lfname ${pfx}_LF.txt" '
+ compare_files $lfname ${pfx}_LF.txt
'
- test_expect_success "compare_files $crlfname ${pfx}CRLF.txt" '
- compare_files $crlfname ${pfx}CRLF.txt
+ test_expect_success "compare_files $crlfname ${pfx}_CRLF.txt" '
+ compare_files $crlfname ${pfx}_CRLF.txt
'
- test_expect_success "compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt" '
- compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt
+ test_expect_success "compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt" '
+ compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt
'
- test_expect_success "compare_files $lfmixcr ${pfx}LF_mix_CR.txt" '
- compare_files $lfmixcr ${pfx}LF_mix_CR.txt
+ test_expect_success "compare_files $lfmixcr ${pfx}_LF_mix_CR.txt" '
+ compare_files $lfmixcr ${pfx}_LF_mix_CR.txt
'
- test_expect_success "compare_files $crlfnul ${pfx}CRLF_nul.txt" '
- compare_files $crlfnul ${pfx}CRLF_nul.txt
+ test_expect_success "compare_files $crlfnul ${pfx}_CRLF_nul.txt" '
+ compare_files $crlfnul ${pfx}_CRLF_nul.txt
'
}
@@ -232,7 +238,7 @@ checkout_files () {
lfmixcrlf=$1 ; shift
lfmixcr=$1 ; shift
crlfnul=$1 ; shift
- create_gitattributes "$attr" "$ident" &&
+ create_gitattributes "$attr" $ident $aeol &&
git config core.autocrlf $crlf &&
pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
@@ -245,7 +251,7 @@ checkout_files () {
fi
done
- test_expect_success "ls-files --eol attr=$attr $ident $aeol core.autocrlf=$crlf core.eol=$ceol" '
+ test_expect_success "ls-files --eol attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol" '
test_when_finished "rm expect actual" &&
sort <<-EOF >expect &&
i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
@@ -260,19 +266,19 @@ checkout_files () {
sort >actual &&
test_cmp expect actual
'
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
compare_ws_file $pfx $lfname crlf_false_attr__LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
compare_ws_file $pfx $crlfname crlf_false_attr__CRLF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
compare_ws_file $pfx $lfmixcrlf crlf_false_attr__CRLF_mix_LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
compare_ws_file $pfx $lfmixcr crlf_false_attr__LF_mix_CR.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
compare_ws_file $pfx $crlfnul crlf_false_attr__LF_nul.txt
"
}
@@ -386,31 +392,31 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
-commit_chk_wrnNNO false "" "" "" "" "" ""
-commit_chk_wrnNNO true "" "LF_CRLF" "" "" "" ""
-commit_chk_wrnNNO input "" "" "" "" "" ""
-
+# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+commit_chk_wrnNNO "" "" false "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO false "auto" "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO true "auto" "LF_CRLF" "" "LF_CRLF" "" ""
-commit_chk_wrnNNO input "auto" "" "CRLF_LF" "CRLF_LF" "" ""
+commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-commit_chk_wrnNNO false "text" "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO true "text" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "text" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-
-commit_chk_wrnNNO false "-text" "" "" "" "" ""
-commit_chk_wrnNNO true "-text" "" "" "" "" ""
-commit_chk_wrnNNO input "-text" "" "" "" "" ""
-
-commit_chk_wrnNNO false "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO true "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO input "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
+for crlf in true false input
+do
+ commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+done
-commit_chk_wrnNNO false "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO true "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
test_expect_success 'create files cleanup' '
rm -f *.txt &&
@@ -441,24 +447,20 @@ test_expect_success 'commit -text' '
check_files_in_repo input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
'
-# attr LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
-check_in_repo_NNO false "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "auto" LF LF LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO true "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO input "text" LF LF LF LF_mix_CR LF_nul
-
-check_in_repo_NNO false "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-
+for crlf in true false input
+do
+ # attr aeol LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
+ check_in_repo_NNO "" "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+done
################################################################################
# Check how files in the repo are changed when they are checked out
# How to read the table below:
@@ -490,89 +492,47 @@ LFNUL=LF_nul
fi
export CRLF_MIX_LF_CR MIX NL
-checkout_files "" "" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true "" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true crlf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true lf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true native CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true "" CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true lf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true native CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-
-for id in "" ident;
+# Same handling with and without ident
+for id in ""
do
- checkout_files "crlf" "$id" "" false "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "lf" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "-text" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ for ceol in lf crlf native
+ do
+ for crlf in true false input
+ do
+ # -text overrides core.autocrlf and core.eol
+ # text and eol=crlf or eol=lf override core.autocrlf and core.eol
+ checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # currently the same as text, eol=XXX
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+
+ # core.autocrlf false, different core.eol
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # core.autocrlf true
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf = true overrides core.eol
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # text: core.autocrlf = input overrides core.eol
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text=auto + eol=XXX
+ done
+ # text: core.autocrlf=false uses core.eol
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ # auto: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6 04/10] convert.c: ident + core.autocrlf didn't work
2016-03-07 22:34 ` Junio C Hamano
` (21 preceding siblings ...)
2016-04-22 14:53 ` [PATCH v6 03/10] t0027: test cases for combined attributes tboegi
@ 2016-04-22 14:53 ` tboegi
2016-04-22 14:53 ` [PATCH v6 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
` (42 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-22 14:53 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When the ident attributes is set, get_stream_filter() did not obey
core.autocrlf=true, and the file was checked out with LF.
Change the rule when a streaming filter can be used:
- if an external filter is specified, don't use a stream filter.
- if the worktree eol is CRLF and "auto" is active, don't use a stream filter.
- Otherwise the stream filter can be used.
Add test cases in t0027.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 19 +++++++------------
t/t0027-auto-crlf.sh | 2 +-
2 files changed, 8 insertions(+), 13 deletions(-)
diff --git a/convert.c b/convert.c
index f524b8d..b1614bf 100644
--- a/convert.c
+++ b/convert.c
@@ -1380,27 +1380,22 @@ static struct stream_filter *ident_filter(const unsigned char *sha1)
struct stream_filter *get_stream_filter(const char *path, const unsigned char *sha1)
{
struct conv_attrs ca;
- enum crlf_action crlf_action;
struct stream_filter *filter = NULL;
convert_attrs(&ca, path);
-
if (ca.drv && (ca.drv->smudge || ca.drv->clean))
- return filter;
+ return NULL;
+
+ if (ca.crlf_action == CRLF_AUTO || ca.crlf_action == CRLF_AUTO_CRLF)
+ return NULL;
if (ca.ident)
filter = ident_filter(sha1);
- crlf_action = ca.crlf_action;
-
- if ((crlf_action == CRLF_BINARY) ||
- crlf_action == CRLF_AUTO_INPUT ||
- (crlf_action == CRLF_TEXT_INPUT))
- filter = cascade_filter(filter, &null_filter_singleton);
-
- else if (output_eol(crlf_action) == EOL_CRLF &&
- !(crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_CRLF))
+ if (output_eol(ca.crlf_action) == EOL_CRLF)
filter = cascade_filter(filter, lf_to_crlf_filter());
+ else
+ filter = cascade_filter(filter, &null_filter_singleton);
return filter;
}
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index fd5e326..9372589 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -493,7 +493,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6 05/10] read-cache: factor out get_sha1_from_index() helper
2016-03-07 22:34 ` Junio C Hamano
` (22 preceding siblings ...)
2016-04-22 14:53 ` [PATCH v6 04/10] convert.c: ident + core.autocrlf didn't work tboegi
@ 2016-04-22 14:53 ` tboegi
2016-04-22 14:53 ` [PATCH v6 06/10] convert.c: stream and early out tboegi
` (41 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-22 14:53 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Factor out the retrieval of the sha1 for a given path in
read_blob_data_from_index() into the function get_sha1_from_index().
This will be used in the next commit, when convert.c can do the
analyze for "text=auto" without slurping the whole blob into memory
at once.
Add a wrapper definition get_sha1_from_cache().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
cache.h | 3 +++
read-cache.c | 29 ++++++++++++++++++-----------
2 files changed, 21 insertions(+), 11 deletions(-)
diff --git a/cache.h b/cache.h
index 2711048..867ceb5 100644
--- a/cache.h
+++ b/cache.h
@@ -379,6 +379,7 @@ extern void free_name_hash(struct index_state *istate);
#define unmerge_cache_entry_at(at) unmerge_index_entry_at(&the_index, at)
#define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)
#define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))
+#define get_sha1_from_cache(path) get_sha1_from_index (&the_index, (path))
#endif
enum object_type {
@@ -1040,6 +1041,8 @@ static inline void *read_sha1_file(const unsigned char *sha1, enum object_type *
return read_sha1_file_extended(sha1, type, size, LOOKUP_REPLACE_OBJECT);
}
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path);
+
/*
* This internal function is only declared here for the benefit of
* lookup_replace_object(). Please do not call it directly.
diff --git a/read-cache.c b/read-cache.c
index d9fb78b..a3ef967 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -2263,13 +2263,27 @@ int index_name_is_other(const struct index_state *istate, const char *name,
void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
{
- int pos, len;
+ const unsigned char *sha1;
unsigned long sz;
enum object_type type;
void *data;
- len = strlen(path);
- pos = index_name_pos(istate, path, len);
+ sha1 = get_sha1_from_index(istate, path);
+ if (!sha1)
+ return NULL;
+ data = read_sha1_file(sha1, &type, &sz);
+ if (!data || type != OBJ_BLOB) {
+ free(data);
+ return NULL;
+ }
+ if (size)
+ *size = sz;
+ return data;
+}
+
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path)
+{
+ int pos = index_name_pos(istate, path, strlen(path));
if (pos < 0) {
/*
* We might be in the middle of a merge, in which
@@ -2285,14 +2299,7 @@ void *read_blob_data_from_index(struct index_state *istate, const char *path, un
}
if (pos < 0)
return NULL;
- data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
- if (!data || type != OBJ_BLOB) {
- free(data);
- return NULL;
- }
- if (size)
- *size = sz;
- return data;
+ return (istate->cache[pos]->sha1);
}
void stat_validity_clear(struct stat_validity *sv)
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6 06/10] convert.c: stream and early out
2016-03-07 22:34 ` Junio C Hamano
` (23 preceding siblings ...)
2016-04-22 14:53 ` [PATCH v6 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
@ 2016-04-22 14:53 ` tboegi
2016-04-22 14:53 ` [PATCH v6 07/10] convert: unify the "auto" handling of CRLF tboegi
` (40 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-22 14:53 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When statistics are done for the autocrlf handling, the search in
the content can be stopped, if e.g
- a search for binary is done, and a NUL character is found
- a search for CRLF is done, and the first CRLF is found.
Similar when statistics for binary vs non-binary are gathered:
Whenever a lone CR or NUL is found, the search can be aborted.
When checking out files in "auto" mode, any file that has a "lone CR"
or a CRLF will not be converted, so the search can be aborted early.
Add the new bit, CONVERT_STAT_BITS_ANY_CR,
which is set for either lone CR or CRLF.
Many binary files have a NUL very early (within the first few bytes,
latest within the first 1..2K).
It is often not necessary to load the whole content of a file or blob
into memory.
Use a streaming handling for blobs and files in the worktree.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 159 ++++++++++++++++++++++++++++++++++++++++----------------------
1 file changed, 103 insertions(+), 56 deletions(-)
diff --git a/convert.c b/convert.c
index b1614bf..24ab095 100644
--- a/convert.c
+++ b/convert.c
@@ -3,6 +3,7 @@
#include "run-command.h"
#include "quote.h"
#include "sigchain.h"
+#include "streaming.h"
/*
* convert.c - convert a file when checking it out and checking it in.
@@ -13,10 +14,10 @@
* translation when the "text" attribute or "auto_crlf" option is set.
*/
-/* Stat bits: When BIN is set, the txt bits are unset */
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
+#define CONVERT_STAT_BITS_ANY_CR 0x8
enum crlf_action {
CRLF_UNDEFINED,
@@ -31,30 +32,36 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned nul, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonecr, lonelf, crlf;
/* These are just approximations! */
unsigned printable, nonprintable;
};
-static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
+static void do_gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
{
unsigned long i;
- memset(stats, 0, sizeof(*stats));
-
+ if (!buf || !size)
+ return;
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
+ stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
stats->crlf++;
i++;
- } else
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
+ } else {
stats->lonecr++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+ }
continue;
}
if (c == '\n') {
stats->lonelf++;
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_LF;
continue;
}
if (c == 127)
@@ -67,7 +74,7 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
stats->printable++;
break;
case 0:
- stats->nul++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
/* fall through */
default:
stats->nonprintable++;
@@ -75,6 +82,8 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
}
else
stats->printable++;
+ if (stats->stat_bits & earlyout)
+ break; /* We found what we have been searching for */
}
/* If file ends with EOF then don't count this EOF as non-printable. */
@@ -86,41 +95,62 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
* The same heuristics as diff.c::mmfile_is_binary()
* We treat files with bare CR as binary
*/
-static int convert_is_binary(unsigned long size, const struct text_stat *stats)
+static void convert_nonprintable(struct text_stat *stats)
{
- if (stats->lonecr)
- return 1;
- if (stats->nul)
- return 1;
if ((stats->printable >> 7) < stats->nonprintable)
- return 1;
- return 0;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+}
+
+static void gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
+{
+ memset(stats, 0, sizeof(*stats));
+ do_gather_stats(buf, size, stats, earlyout);
+ convert_nonprintable(stats);
}
-static unsigned int gather_convert_stats(const char *data, unsigned long size)
+
+static unsigned get_convert_stats_sha1(unsigned const char *sha1,
+ unsigned earlyout)
{
+ struct git_istream *st;
struct text_stat stats;
- int ret = 0;
- if (!data || !size)
- return 0;
- gather_stats(data, size, &stats);
- if (convert_is_binary(size, &stats))
- ret |= CONVERT_STAT_BITS_BIN;
- if (stats.crlf)
- ret |= CONVERT_STAT_BITS_TXT_CRLF;
- if (stats.lonelf)
- ret |= CONVERT_STAT_BITS_TXT_LF;
+ enum object_type type;
+ unsigned long sz;
- return ret;
+ if (!sha1)
+ return 0;
+ memset(&stats, 0, sizeof(stats));
+ st = open_istream(sha1, &type, &sz, NULL);
+ if (!st) {
+ return 0;
+ }
+ if (type != OBJ_BLOB)
+ goto close_and_exit_i;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read_istream(st, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+close_and_exit_i:
+ close_istream(st);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
}
-static const char *gather_convert_stats_ascii(const char *data, unsigned long size)
+static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned int convert_stats = gather_convert_stats(data, size);
-
+ unsigned mask = CONVERT_STAT_BITS_TXT_LF |
+ CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats) {
+ switch (convert_stats & mask) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -132,24 +162,45 @@ static const char *gather_convert_stats_ascii(const char *data, unsigned long si
}
}
+static unsigned get_convert_stats_wt(const char *path)
+{
+ struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ int fd;
+ memset(&stats, 0, sizeof(stats));
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ return 0;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read(fd, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+ close(fd);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
+}
+
const char *get_cached_convert_stats_ascii(const char *path)
{
- const char *ret;
- unsigned long sz;
- void *data = read_blob_data_from_cache(path, &sz);
- ret = gather_convert_stats_ascii(data, sz);
- free(data);
- return ret;
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
}
const char *get_wt_convert_stats_ascii(const char *path)
{
- const char *ret = "";
- struct strbuf sb = STRBUF_INIT;
- if (strbuf_read_file(&sb, path, 0) >= 0)
- ret = gather_convert_stats_ascii(sb.buf, sb.len);
- strbuf_release(&sb);
- return ret;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_wt(path);
+ return convert_stats_ascii(convert_stats);
}
static int text_eol_is_crlf(void)
@@ -219,16 +270,10 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
static int has_cr_in_index(const char *path)
{
- unsigned long sz;
- void *data;
- int has_cr;
-
- data = read_blob_data_from_cache(path, &sz);
- if (!data)
- return 0;
- has_cr = memchr(data, '\r', sz) != NULL;
- free(data);
- return has_cr;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_ANY_CR);
+ return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -249,10 +294,10 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
@@ -309,11 +354,13 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
+
if (!len || output_eol(crlf_action) != EOL_CRLF)
return 0;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, earlyout);
/* No "naked" LF? Nothing to convert, regardless. */
if (!stats.lonelf)
@@ -327,7 +374,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
}
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
}
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6 07/10] convert: unify the "auto" handling of CRLF
2016-03-07 22:34 ` Junio C Hamano
` (24 preceding siblings ...)
2016-04-22 14:53 ` [PATCH v6 06/10] convert.c: stream and early out tboegi
@ 2016-04-22 14:53 ` tboegi
2016-04-22 14:53 ` [PATCH v6 08/10] convert.c: more safer crlf handling with text attribute tboegi
` (39 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-22 14:53 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Before this change,
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
would have the same effect as
$ echo "* text" >.gitattributes
$ git config core.eol crlf
Since the 'eol' attribute had higher priority than 'text=auto', this may
corrupt binary files and is not what most users expect to happen.
Make the 'eol' attribute to obey 'text=auto', and now
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
behaves the same as
$ echo "* text=auto" >.gitattributes
$ git config core.eol crlf
In other words,
$ echo "* text=auto eol=crlf" >.gitattributes
has the same effect as
$ git config core.autocrlf true
and
$ echo "* text=auto eol=lf" >.gitattributes
has the same effect as
$ git config core.autocrlf input
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 14 +++++++-------
Documentation/gitattributes.txt | 15 +++++++++------
convert.c | 42 +++++++++++++++++++++--------------------
convert.h | 3 ++-
t/t0025-crlf-auto.sh | 4 ++--
t/t0027-auto-crlf.sh | 32 +++++++++++++++----------------
t/t6038-merge-text-auto.sh | 23 ++++++++++++++--------
7 files changed, 73 insertions(+), 60 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 155f988..117c2f3 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -389,13 +389,13 @@ 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',
+ Setting this variable to "true" is the same as setting
+ the `text` attribute to "auto" on all files and core.eol to "crlf".
+ Set to true if you want to have `CRLF` line endings in your
+ working directory and the repository has LF line endings.
+ Text files are guaranteed not to be normalized: files that contain
+ `CRLF` in the repository will not be touched.
+ This variable can be set to 'input',
in which case no output conversion is performed.
core.symlinks::
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index e3b1de8..d7a124b 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -115,6 +115,7 @@ 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.eol` configuration variable for all text files.
+Note that `core.autocrlf` overrides `core.eol`
Set::
@@ -130,8 +131,9 @@ Unset::
Set to string value "auto"::
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.
+ end-of-line conversion. If Git decides that the content is
+ text, its line endings are converted to LF on checkin.
+ When the file has been commited with CRLF, no conversion is done.
Unspecified::
@@ -146,7 +148,7 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line normalization without any
+working directory. It enables end-of-line conversion without any
content checks, effectively setting the `text` attribute.
Set to string value "crlf"::
@@ -186,9 +188,10 @@ the working directory, and prevent .jpg files from being normalized
regardless of their content.
------------------------
+* text=auto
*.txt text
-*.vcproj eol=crlf
-*.sh eol=lf
+*.vcproj text eol=crlf
+*.sh text eol=lf
*.jpg -text
------------------------
@@ -198,7 +201,7 @@ 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.
+config variable "core.autocrlf" without using any attributes.
------------------------
[core]
diff --git a/convert.c b/convert.c
index 24ab095..3782172 100644
--- a/convert.c
+++ b/convert.c
@@ -227,7 +227,9 @@ static enum eol output_eol(enum crlf_action crlf_action)
return EOL_LF;
case CRLF_UNDEFINED:
case CRLF_AUTO_CRLF:
+ return EOL_CRLF;
case CRLF_AUTO_INPUT:
+ return EOL_LF;
case CRLF_TEXT:
case CRLF_AUTO:
/* fall through */
@@ -299,17 +301,15 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
-
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /*
- * 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 the file in the index has any CR in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ if (checksafe == SAFE_CRLF_RENORMALIZE)
+ checksafe = SAFE_CRLF_FALSE;
+ else if (has_cr_in_index(path))
+ return 0;
}
-
check_safe_crlf(path, crlf_action, &stats, checksafe);
/* Optimization: No CRLF? Nothing to convert, regardless. */
@@ -367,12 +367,10 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
- }
+ /* If we have any CR or CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (stats.lonecr || stats.crlf )
+ return 0;
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
@@ -833,7 +831,11 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
ca->drv = git_path_check_convert(ccheck + 2);
if (ca->crlf_action != CRLF_BINARY) {
enum eol eol_attr = git_path_check_eol(ccheck + 3);
- if (eol_attr == EOL_LF)
+ if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_LF)
+ ca->crlf_action = CRLF_AUTO_INPUT;
+ else if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_CRLF)
+ ca->crlf_action = CRLF_AUTO_CRLF;
+ else if (eol_attr == EOL_LF)
ca->crlf_action = CRLF_TEXT_INPUT;
else if (eol_attr == EOL_CRLF)
ca->crlf_action = CRLF_TEXT_CRLF;
@@ -892,9 +894,9 @@ const char *get_convert_attr_ascii(const char *path)
case CRLF_AUTO:
return "text=auto";
case CRLF_AUTO_CRLF:
- return "text=auto eol=crlf"; /* This is not supported yet */
+ return "text=auto eol=crlf";
case CRLF_AUTO_INPUT:
- return "text=auto eol=lf"; /* This is not supported yet */
+ return "text=auto eol=lf";
}
return "";
}
@@ -996,7 +998,7 @@ int renormalize_buffer(const char *path, const char *src, size_t len, struct str
src = dst->buf;
len = dst->len;
}
- return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_FALSE);
+ return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_RENORMALIZE);
}
/*****************************************************************
diff --git a/convert.h b/convert.h
index ccf436b..81b6cdf 100644
--- a/convert.h
+++ b/convert.h
@@ -7,7 +7,8 @@
enum safe_crlf {
SAFE_CRLF_FALSE = 0,
SAFE_CRLF_FAIL = 1,
- SAFE_CRLF_WARN = 2
+ SAFE_CRLF_WARN = 2,
+ SAFE_CRLF_RENORMALIZE = 4
};
extern enum safe_crlf safe_crlf;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index c164b46..d0bee08 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -114,7 +114,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
+test_expect_success 'text=auto, autocrlf=true does not normalize CRLF files' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
git config core.autocrlf true &&
@@ -126,7 +126,7 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
LFonlydiff=$(git diff LFonly) &&
CRLFonlydiff=$(git diff CRLFonly) &&
LFwithNULdiff=$(git diff LFwithNUL) &&
- test -z "$LFonlydiff" -a -n "$CRLFonlydiff" -a -z "$LFwithNULdiff"
+ test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 9372589..8367d0b 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -175,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text eol=lf" ;;
- auto,crlf) echo "text eol=crlf" ;;
+ auto,lf) echo "text=auto eol=lf" ;;
+ auto,crlf) echo "text=auto eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -397,10 +397,9 @@ commit_chk_wrnNNO "" "" false "" "" "" ""
commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
-commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-
+commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
@@ -408,8 +407,8 @@ do
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
done
@@ -454,9 +453,9 @@ do
check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
@@ -493,7 +492,8 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in "" ident
+#for id in "" ident
+for id in ""
do
for ceol in lf crlf native
do
@@ -509,7 +509,7 @@ do
checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
@@ -517,7 +517,7 @@ do
# core.autocrlf true
checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
@@ -531,8 +531,8 @@ do
checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 85c10b0..33b77ee 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -16,6 +16,13 @@ test_description='CRLF merge conflict across text=auto change
test_have_prereq SED_STRIPS_CR && SED_OPTIONS=-b
+compare_files () {
+ tr '\015\000' QN <"$1" >"$1".expect &&
+ tr '\015\000' QN <"$2" >"$2".actual &&
+ test_cmp "$1".expect "$2".actual &&
+ rm "$1".expect "$2".actual
+}
+
test_expect_success setup '
git config core.autocrlf false &&
@@ -30,7 +37,7 @@ test_expect_success setup '
git branch side &&
echo "* text=auto" >.gitattributes &&
- touch file &&
+ echo first line >file &&
git add .gitattributes file &&
test_tick &&
git commit -m "normalize file" &&
@@ -81,7 +88,7 @@ test_expect_success 'Merge after setting text=auto' '
rm -f .gitattributes &&
git reset --hard a &&
git merge b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Merge addition of text=auto' '
@@ -99,7 +106,7 @@ test_expect_success 'Merge addition of text=auto' '
rm -f .gitattributes &&
git reset --hard b &&
git merge a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
@@ -121,7 +128,7 @@ test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
git reset --hard a &&
test_must_fail git merge b &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
@@ -143,7 +150,7 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
git reset --hard b &&
test_must_fail git merge a &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_failure 'checkout -m after setting text=auto' '
@@ -158,7 +165,7 @@ test_expect_failure 'checkout -m after setting text=auto' '
git reset --hard initial &&
git checkout a -- . &&
git checkout -m b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'checkout -m addition of text=auto' '
@@ -173,7 +180,7 @@ test_expect_failure 'checkout -m addition of text=auto' '
git reset --hard initial &&
git checkout b -- . &&
git checkout -m a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'cherry-pick patch from after text=auto was added' '
@@ -187,7 +194,7 @@ test_expect_failure 'cherry-pick patch from after text=auto was added' '
git reset --hard b &&
test_must_fail git cherry-pick a >err 2>&1 &&
grep "[Nn]othing added" err &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Test delete/normalize conflict' '
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6 08/10] convert.c: more safer crlf handling with text attribute
2016-03-07 22:34 ` Junio C Hamano
` (25 preceding siblings ...)
2016-04-22 14:53 ` [PATCH v6 07/10] convert: unify the "auto" handling of CRLF tboegi
@ 2016-04-22 14:53 ` tboegi
2016-04-22 14:53 ` [PATCH v6 09/10] t6038; use crlf on all platforms tboegi
` (38 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-22 14:53 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
A follow-up after a discussion how to fix the flaky execution
of t0025, gmane/$284352.
This patch extends the work done in commit c480539:
"Make it work also for un-normalized repositories". Make sure that CRLF
can be converted round trip, or don't convert them at all.
The old handling would treat a file as unchanged after checkout,
as long as it is not touched in the work tree and mtime matches the value
recorded in the index.
When the mtime is changed in the working tree, or the inode is changed,
the file is reported as modified.
The following sequence is now handled reproducable:
$ git init
$ printf "line1\r\n" >file.bat
$ git add file.bat
$ git commit -m "Add file with CRLF" file.bat
$ echo "*.bat text eol=crlf" >.gitattributes
$ git commit -m "bat files should have CRLF"
$ git status
# nothing to commit, working directory clean
$ git push <upstream>
$ printf "newline\r\n" >>file.bat
$ mv file.bat file.sav
$ git checkout file.bat
$ git status
#modified: file.bat
The new handling makes sure that after running "git reset --hard".
"git status" reports the working tree as clean regarding CRLF conversion.
It makes sure that the Git-internal eol conversion is
doing roundtrip. A user can still write an external smudge/clean filter
outside Git, which doesn't do a roundtrip and the working directory is
not clean.
The functionality of has_cr_in_index() is turned into has_crlf_in_index(),
and the function is integrated into would_convert_crlf_at_commit().
Check for CRLF in the index instead of CR, the bit CONVERT_STAT_BITS_ANY_CR
is no longer used and removed, as well as "lonecr" in struct text_stat.
Rewrite check_safe_crlf() in convert.c to simulate checkin-checkout,
to detect whether any line endings are converted.
Add a warning, similar to the CRLF-LF replacement, when a file is commited,
and after the next checkout the line endings are not they should be.
Modify the lf_to_crlf_filter:
Files with LF are converted into CRLF, file with CRLF are not changed.
Files with mixed line endings are not converted, the filter fails, and Git
falls back to the non-streaming handling, see write_entry().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/gitattributes.txt | 19 ++--
convert.c | 233 +++++++++++++++++++++++++---------------
t/t0025-crlf-auto.sh | 8 +-
t/t0027-auto-crlf.sh | 92 ++++++++--------
4 files changed, 212 insertions(+), 140 deletions(-)
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index d7a124b..836461d 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -110,7 +110,7 @@ repository upon 'git add' and 'git commit'.
`text`
^^^^^^
-This attribute enables and controls end-of-line normalization. When a
+This attribute enables and controls end-of-line conversion. 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
@@ -120,8 +120,11 @@ Note that `core.autocrlf` overrides `core.eol`
Set::
Setting the `text` attribute on a path enables end-of-line
- normalization and marks the path as a text file. End-of-line
+ conversion and marks the path as a text file. End-of-line
conversion takes place without guessing the content type.
+ Files that have been commited with CRLF before the text attribute
+ is set and commited are not normalized. No end-of-line conversion
+ is done at checkout or checkin.
Unset::
@@ -131,9 +134,9 @@ Unset::
Set to string value "auto"::
When `text` is set to "auto", the path is marked for automatic
- end-of-line conversion. If Git decides that the content is
- text, its line endings are converted to LF on checkin.
- When the file has been commited with CRLF, no conversion is done.
+ end-of-line normalization. If Git decides that the content is
+ text, and the path has no CRLF in the index,
+ its line endings are converted to LF on checkin.
Unspecified::
@@ -148,8 +151,10 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line conversion without any
-content checks, effectively setting the `text` attribute.
+working directory. It sets the `text` attribute, unless `text=auto`
+is specified.
+When the file had been commited with CRLF in the index, no conversion
+is done at checkout or commit.
Set to string value "crlf"::
diff --git a/convert.c b/convert.c
index 3782172..8d4c42a 100644
--- a/convert.c
+++ b/convert.c
@@ -17,7 +17,8 @@
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
-#define CONVERT_STAT_BITS_ANY_CR 0x8
+
+#define CONVERT_STAT_BITS_MIXED (CONVERT_STAT_BITS_TXT_LF | CONVERT_STAT_BITS_TXT_CRLF)
enum crlf_action {
CRLF_UNDEFINED,
@@ -32,7 +33,7 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned stat_bits, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonelf;
/* These are just approximations! */
unsigned printable, nonprintable;
@@ -48,13 +49,10 @@ static void do_gather_stats(const char *buf, unsigned long size,
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
- stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
- stats->crlf++;
i++;
stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
} else {
- stats->lonecr++;
stats->stat_bits |= CONVERT_STAT_BITS_BIN;
}
continue;
@@ -135,7 +133,7 @@ static unsigned get_convert_stats_sha1(unsigned const char *sha1,
if (!readlen)
break;
do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
- if (stats.stat_bits & earlyout)
+ if ((stats.stat_bits & earlyout) == earlyout)
break; /* We found what we have been searching for */
}
close_and_exit_i:
@@ -146,11 +144,9 @@ close_and_exit_i:
static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned mask = CONVERT_STAT_BITS_TXT_LF |
- CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats & mask) {
+ switch (convert_stats) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -162,7 +158,16 @@ static const char *convert_stats_ascii(unsigned convert_stats)
}
}
-static unsigned get_convert_stats_wt(const char *path)
+const char *get_cached_convert_stats_ascii(const char *path)
+{
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
+}
+
+const char *get_wt_convert_stats_ascii(const char *path)
{
struct text_stat stats;
unsigned earlyout = CONVERT_STAT_BITS_BIN;
@@ -184,23 +189,7 @@ static unsigned get_convert_stats_wt(const char *path)
}
close(fd);
convert_nonprintable(&stats);
- return stats.stat_bits;
-}
-
-const char *get_cached_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- unsigned earlyout = CONVERT_STAT_BITS_BIN;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- earlyout);
- return convert_stats_ascii(convert_stats);
-}
-
-const char *get_wt_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_wt(path);
- return convert_stats_ascii(convert_stats);
+ return convert_stats_ascii(stats.stat_bits);
}
static int text_eol_is_crlf(void)
@@ -239,43 +228,95 @@ static enum eol output_eol(enum crlf_action crlf_action)
return core_eol;
}
+static int would_convert_lf_at_checkout(unsigned convert_stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ if (output_eol(crlf_action) != EOL_CRLF)
+ return 0;
+
+ /* No "naked" LF? Nothing to convert, regardless. */
+ if (!convert_stats & CONVERT_STAT_BITS_TXT_LF)
+ return 0;
+
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ /* auto: binary files are not converted */
+ if (convert_stats & CONVERT_STAT_BITS_BIN)
+ return 0;
+ }
+ /* If we have any CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+
+}
+
+static int would_convert_crlf_at_commit(const char * path,
+ const struct text_stat *stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ unsigned stat_bits_index;
+ /* No CRLF? Nothing to convert, regardless. */
+ if (!(stats->stat_bits & CONVERT_STAT_BITS_TXT_CRLF))
+ return 0;
+ /*
+ * If the file in the index has any CRLF in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ stat_bits_index = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_TXT_CRLF);
+ if (stat_bits_index & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+}
+
static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
- struct text_stat *stats, enum safe_crlf checksafe)
+ enum safe_crlf checksafe,
+ unsigned convert_stats, unsigned new_convert_stats)
{
+ enum eol new_eol = output_eol(crlf_action);
+ const char *err_warn_msg = NULL;
if (!checksafe)
return;
-
- if (output_eol(crlf_action) == EOL_LF) {
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
/*
* 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.\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 (output_eol(crlf_action) == EOL_CRLF) {
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if (convert_stats & CONVERT_STAT_BITS_TXT_LF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_LF)) {
/*
* CRLFs would be added by checkout:
* check if we have "naked" LFs
*/
- if (stats->lonelf) {
- if (checksafe == SAFE_CRLF_WARN)
- 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);
- }
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if ((new_convert_stats & CONVERT_STAT_BITS_MIXED) == CONVERT_STAT_BITS_MIXED)
+ err_warn_msg = "mixed eol";
+ else if (new_eol == EOL_LF && new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ err_warn_msg = "CRLF";
+
+ if (err_warn_msg) {
+ if (checksafe == SAFE_CRLF_WARN)
+ warning("%s will be present after commit and checkout in %s.",
+ err_warn_msg, path);
+ else
+ die("%s will be present after commit and checkout in %s",
+ err_warn_msg, path);
}
-}
-
-static int has_cr_in_index(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- CONVERT_STAT_BITS_ANY_CR);
- return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -284,7 +325,7 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
{
struct text_stat stats;
char *dst;
-
+ int convert_crlf;
if (crlf_action == CRLF_BINARY ||
(src && !len))
return 0;
@@ -296,24 +337,42 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
-
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
- /*
- * If the file in the index has any CR in it, do not convert.
- * This is the new safer autocrlf handling.
- */
- if (checksafe == SAFE_CRLF_RENORMALIZE)
- checksafe = SAFE_CRLF_FALSE;
- else if (has_cr_in_index(path))
- return 0;
+ } else {
+ gather_stats(src, len, &stats, 0);
+ }
+ if (checksafe == SAFE_CRLF_RENORMALIZE) {
+ convert_crlf = 1;
+ checksafe = SAFE_CRLF_FALSE;
+ } else {
+ convert_crlf = would_convert_crlf_at_commit(path, &stats, len,
+ crlf_action);
}
- check_safe_crlf(path, crlf_action, &stats, checksafe);
- /* Optimization: No CRLF? Nothing to convert, regardless. */
- if (!stats.crlf)
+ if (checksafe) {
+ unsigned convert_stats = stats.stat_bits;
+ unsigned new_convert_stats = convert_stats;
+ /* Simulate commit */
+ if (convert_crlf &&
+ (new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_LF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_CRLF;
+ }
+ /* Simulate checkout */
+ if (would_convert_lf_at_checkout(new_convert_stats,
+ len, crlf_action)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_CRLF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_LF;
+ }
+ check_safe_crlf(path, crlf_action, checksafe,
+ convert_stats, new_convert_stats);
+ }
+ if (!convert_crlf)
return 0;
/*
@@ -327,7 +386,9 @@ 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 (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
/*
* If we guessed, we already know we rejected a file with
* lone CR, and we can strip a CR without looking at what
@@ -354,28 +415,15 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
- unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
-
-
- if (!len || output_eol(crlf_action) != EOL_CRLF)
+ unsigned earlyout = 0; /* Need to count lonelf */
+ if (!len)
return 0;
gather_stats(src, len, &stats, earlyout);
-
- /* No "naked" LF? Nothing to convert, regardless. */
- if (!stats.lonelf)
+ if (!would_convert_lf_at_checkout(stats.stat_bits,
+ len, crlf_action))
return 0;
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
-
- if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
- return 0;
- }
-
/* are we "faking" in place editing ? */
if (src == buf->buf)
to_free = strbuf_detach(buf, NULL);
@@ -1067,6 +1115,8 @@ int is_null_stream_filter(struct stream_filter *filter)
struct lf_to_crlf_filter {
struct stream_filter filter;
unsigned has_held:1;
+ unsigned expanded_loneLF:1;
+ unsigned had_CRLF:1;
char held;
};
@@ -1107,7 +1157,12 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
char ch = input[i];
if (ch == '\n') {
- output[o++] = '\r';
+ if (!lf_to_crlf->had_CRLF) {
+ output[o++] = '\r';
+ lf_to_crlf->expanded_loneLF = 1;
+ }
+ if (was_cr)
+ lf_to_crlf->had_CRLF = 1;
} else if (was_cr) {
/*
* Previous round saw CR and it is not followed
@@ -1136,6 +1191,14 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
was_cr = 0;
output[o++] = ch;
+ if (lf_to_crlf->expanded_loneLF &&
+ lf_to_crlf->had_CRLF) {
+ /*
+ * Mixed EOL, round trip not possible.
+ */
+ return 1;
+ }
+
}
*osize_p -= o;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index d0bee08..b5f93e2 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 "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'crlf=true causes a CRLF file to be normalized' '
+test_expect_success 'crlf=true causes a CRLF file not to be normalized' '
# Backwards compatibility check
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
@@ -49,10 +49,10 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
-test_expect_success 'text=true causes a CRLF file to be normalized' '
+test_expect_success 'text=true causes a CRLF file not to be normalized' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
echo "CRLFonly text" > .gitattributes &&
@@ -61,7 +61,7 @@ test_expect_success 'text=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 8367d0b..a16e513 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -71,10 +71,14 @@ check_warning () {
case "$1" in
LF_CRLF) echo "warning: LF will be replaced by CRLF" >"$2".expect ;;
CRLF_LF) echo "warning: CRLF will be replaced by LF" >"$2".expect ;;
+ CRLF) echo "warning: CRLF will be present after commit and checkout" >"$2".expect ;;
+ mixed) echo "warning: mixed eol will be present after commit and checkout" >"$2".expect ;;
'') >"$2".expect ;;
*) echo >&2 "Illegal 1": "$1" ; return false ;;
esac
- grep "will be replaced by" "$2" | sed -e "s/\(.*\) in [^ ]*$/\1/" | uniq >"$2".actual
+ egrep "will be replaced by|will be present after commit" "$2" |
+ sed -e "s/\(.*\) in [^ ]*$/\1/" |
+ uniq >"$2".actual
test_cmp "$2".expect "$2".actual
}
@@ -169,7 +173,7 @@ stats_ascii () {
# Take none (=empty), one or two args
# convert.c: eol=XX overrides text=auto
attr_ascii () {
- case $1,$2 in
+ case "$1","$2" in
-text,*) echo "-text" ;;
text,) echo "text" ;;
text,lf) echo "text eol=lf" ;;
@@ -349,10 +353,12 @@ then
WILC=LF_CRLF
WICL=
WAMIX=LF_CRLF
+ Pcrlf=
else
WILC=
WICL=CRLF_LF
WAMIX=CRLF_LF
+ Pcrlf=CRLF
fi
# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
@@ -392,31 +398,32 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
commit_chk_wrnNNO "" "" false "" "" "" "" ""
-commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "" "" input "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "" "" input "" CRLF mixed "" ""
+
+commit_chk_wrnNNO "auto" "" false "$WILC" "$Pcrlf" mixed "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF mixed "" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$Pcrlf" mixed "$WILC" "$Pcrlf"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" mixed LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF mixed "" CRLF
+
-commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
- commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
- commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" mixed LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF mixed "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" mixed "" ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" mixed LF_CRLF ""
done
-commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
-commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
-
test_expect_success 'create files cleanup' '
rm -f *.txt &&
git -c core.autocrlf=false reset --hard
@@ -456,9 +463,9 @@ do
check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
done
################################################################################
# Check how files in the repo are changed when they are checked out
@@ -479,12 +486,10 @@ done
if test_have_prereq NATIVE_CRLF
then
-MIX_CRLF_LF=CRLF
MIX_LF_CR=CRLF_mix_CR
NL=CRLF
LFNUL=CRLF_nul
else
-MIX_CRLF_LF=CRLF_mix_LF
MIX_LF_CR=LF_mix_CR
NL=LF
LFNUL=LF_nul
@@ -492,8 +497,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-#for id in "" ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
@@ -501,38 +505,38 @@ do
do
# -text overrides core.autocrlf and core.eol
# text and eol=crlf or eol=lf override core.autocrlf and core.eol
- checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text
- checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
- checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
- checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# core.autocrlf true
- checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
- checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text=auto + eol=XXX
done
# text: core.autocrlf=false uses core.eol
- checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false "" $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
+ checkout_files text "$id" "" false native $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6 09/10] t6038; use crlf on all platforms
2016-03-07 22:34 ` Junio C Hamano
` (26 preceding siblings ...)
2016-04-22 14:53 ` [PATCH v6 08/10] convert.c: more safer crlf handling with text attribute tboegi
@ 2016-04-22 14:53 ` tboegi
2016-04-22 14:53 ` [PATCH v6 10/10] ce_compare_data() did not respect conversion tboegi
` (37 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-22 14:53 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
t6038 uses different code, dependig if NATIVE_CRLF is set ot not.
When the native line endings are LF, merge.renormalize is not tested very well.
Change the test to always use CRLF by setting core.eol=crlf.
After doing so, the test fails:
rm '.gitattributes'
rm 'control_file'
rm 'file'
rm 'inert_file'
HEAD is now at 0d9ffb6 add line from b
error: addinfo_cache failed for path 'file'
file: unmerged (cbd69ec7cd12dd0989e853923867d94c8519aa52)
file: unmerged (ad55e240aeb42e0d9a0e18d6d8b02dd82ee3e527)
file: unmerged (99b633103c15c20cebebf821133ab526b0ff90b2)
fatal: git write-tree failed to write a tree
Merging:
0d9ffb6 add line from b
virtual a
found 1 common ancestor:
1c56df1 Initial
Auto-merging file
not ok 4 - Merge addition of text=auto
This will be addressed in the next commit.
---
t/t6038-merge-text-auto.sh | 37 +++++++++++--------------------------
1 file changed, 11 insertions(+), 26 deletions(-)
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 33b77ee..0108ead 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -25,6 +25,7 @@ compare_files () {
test_expect_success setup '
git config core.autocrlf false &&
+ git config core.eol crlf &&
echo first line | append_cr >file &&
echo first line >control_file &&
@@ -79,10 +80,8 @@ test_expect_success 'Merge after setting text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -97,10 +96,8 @@ test_expect_success 'Merge addition of text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -111,15 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected
- else
- echo first line >>expected &&
- echo same line >>expected &&
- echo ======= >>expected
- fi &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
+ echo ======= | append_cr >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -135,15 +126,9 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected
- else
- echo ======= >>expected &&
- echo first line >>expected &&
- echo same line >>expected
- fi &&
+ echo ======= | append_cr >>expected &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6 10/10] ce_compare_data() did not respect conversion
2016-03-07 22:34 ` Junio C Hamano
` (27 preceding siblings ...)
2016-04-22 14:53 ` [PATCH v6 09/10] t6038; use crlf on all platforms tboegi
@ 2016-04-22 14:53 ` tboegi
2016-04-24 15:10 ` [PATCH v6b 01/10] t0027: Make commit_chk_wrnNNO() reliable tboegi
` (36 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-22 14:53 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
We define the working tree file is clean if either:
* the result of running convert_to_git() on the working tree
contents matches what is in the index (because that would mean
doing another "git add" on the path is a no-op); OR
* the result of running convert_to_working_tree() on the content
in the index matches what is in the working tree (because that
would mean doing another "git checkout -f" on the path is a
no-op).
Add an extra check in ce_compare_data() in read_cache.c.
When a file has CRLF in the index, and is checked out into the working tree,
but left unchabged, it is not normalized at the next commit.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
read-cache.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++
t/t6038-merge-text-auto.sh | 14 +++++------
2 files changed, 68 insertions(+), 7 deletions(-)
diff --git a/read-cache.c b/read-cache.c
index a3ef967..48c4b31 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -156,17 +156,78 @@ void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
ce_mark_uptodate(ce);
}
+/*
+ * Compare the data in buf with the data in the file pointed by fd and
+ * return 0 if they are identical, and non-zero if they differ.
+ */
+static int compare_with_fd(const char *input, ssize_t len, int fd)
+{
+ for (;;) {
+ char buf[1024 * 16];
+ ssize_t chunk_len, read_len;
+
+ chunk_len = sizeof(buf) < len ? sizeof(buf) : len;
+ read_len = xread(fd, buf, chunk_len ? chunk_len : 1);
+
+ if (!read_len)
+ /* EOF on the working tree file */
+ return !len ? 0 : -1;
+
+ if (!len)
+ /* we expected there is nothing left */
+ return -1;
+
+ if (memcmp(buf, input, read_len))
+ return -1;
+ input += read_len;
+ len -= read_len;
+ }
+}
+
static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
{
int match = -1;
int fd = open(ce->name, O_RDONLY);
+ /*
+ * Would another "git add" on the path change what is in the
+ * index for the path?
+ */
if (fd >= 0) {
unsigned char sha1[20];
if (!index_fd(sha1, fd, st, OBJ_BLOB, ce->name, 0))
match = hashcmp(sha1, ce->sha1);
/* index_fd() closed the file descriptor already */
}
+ if (!match)
+ return match;
+
+ /*
+ * Would another "git checkout -f" out of the index change
+ * what is in the working tree file?
+ */
+ fd = open(ce->name, O_RDONLY);
+ if (fd >= 0) {
+ enum object_type type;
+ unsigned long size_long;
+ void *data = read_sha1_file(ce->sha1, &type, &size_long);
+
+ if (type == OBJ_BLOB) {
+ struct strbuf worktree = STRBUF_INIT;
+ if (convert_to_working_tree(ce->name, data,
+ size_long,
+ &worktree)) {
+ size_t size;
+ free(data);
+ data = strbuf_detach(&worktree, &size);
+ size_long = size;
+ }
+ if (!compare_with_fd(data, size_long, fd))
+ match = 0;
+ }
+ free(data);
+ close(fd);
+ }
return match;
}
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 0108ead..565daf3 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -108,9 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
+ echo ======= >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -121,14 +121,13 @@ test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
fuzz_conflict file >file.fuzzy &&
compare_files expected file.fuzzy
'
-
test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
+ echo ======= >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
@@ -138,6 +137,7 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
compare_files expected file.fuzzy
'
+
test_expect_failure 'checkout -m after setting text=auto' '
cat <<-\EOF >expected &&
first line
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH v6 01/10] t0027: Make more reliable
2016-04-22 14:38 ` [PATCH v6 01/10] t0027: Make more reliable tboegi
@ 2016-04-22 22:03 ` Junio C Hamano
2016-04-24 3:45 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-04-22 22:03 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
> Subject: Re: [PATCH v6 01/10] t0027: Make more reliable
"Make more reliable" does not sound very grammatical.
> Make the commit_chk_wrnNNO test in t0027 more reliable:
Neither is the colon at the end.
> When the attributes of a commited file are changed and the file is otherwise
> unchanged, Git may not detect that the next commit may need to treat the
> file as changed.
> This happens when lstat() doesn't detect a change, since neither inode,
> mtime nor size are changed.
>
> Add a singe "Z" character to change the file size.
> Ignore it when comparing the files later.
>
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
> ---
> Changes since v5:
> - send the whole series, now 10/10
> - Removed the "will change in future" in one commit msg
> - Don't leak the filer in 4/10
> t/t0027-auto-crlf.sh | 3 ++-
> 1 file changed, 2 insertions(+), 1 deletion(-)
>
> diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
> index f33962b..9fe539b 100755
> --- a/t/t0027-auto-crlf.sh
> +++ b/t/t0027-auto-crlf.sh
> @@ -12,7 +12,7 @@ fi
>
> compare_files () {
> tr '\015\000' QN <"$1" >"$1".expect &&
> - tr '\015\000' QN <"$2" >"$2".actual &&
> + tr '\015\000' QN <"$2" | tr -d 'Z' >"$2".actual &&
> test_cmp "$1".expect "$2".actual &&
> rm "$1".expect "$2".actual
> }
> @@ -114,6 +114,7 @@ commit_chk_wrnNNO () {
> do
> fname=${pfx}_$f.txt &&
> cp $f $fname &&
> + printf Z >>"$fname" &&
> git -c core.autocrlf=$crlf add $fname 2>/dev/null &&
> git -c core.autocrlf=$crlf commit -m "commit_$fname" $fname >"${pfx}_$f.err" 2>&1
> done
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v6 01/10] t0027: Make more reliable
2016-04-22 22:03 ` Junio C Hamano
@ 2016-04-24 3:45 ` Torsten Bögershausen
0 siblings, 0 replies; 126+ messages in thread
From: Torsten Bögershausen @ 2016-04-24 3:45 UTC (permalink / raw)
To: Junio C Hamano, tboegi; +Cc: git
On 2016-04-23 00.03, Junio C Hamano wrote:
> tboegi@web.de writes:
>
>> From: Torsten Bögershausen <tboegi@web.de>
>> Subject: Re: [PATCH v6 01/10] t0027: Make more reliable
>
> "Make more reliable" does not sound very grammatical.
>
>> Make the commit_chk_wrnNNO test in t0027 more reliable:
>
> Neither is the colon at the end.
>
After Re-reading the series (with fresh eyes)
I found more spelling errors, typos in different commit messages.
9/10 is missing the SOB.
How about this for 1/10:
Subject: [PATCH v6 01/10] t0027: Make commit_chk_wrnNNO() reliable
When the content of a commited file is unchanged and the attributes are changed,
Git may not detect that the next commit must treat the
file as changed.
This happens when lstat() doesn't detect a change, since neither inode,
mtime nor size are changed.
Add a singe "Z" character to change the file size.
Ignore it when comparing the files later.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH v6b 01/10] t0027: Make commit_chk_wrnNNO() reliable
2016-03-07 22:34 ` Junio C Hamano
` (28 preceding siblings ...)
2016-04-22 14:53 ` [PATCH v6 10/10] ce_compare_data() did not respect conversion tboegi
@ 2016-04-24 15:10 ` tboegi
2016-04-24 15:11 ` [PATCH v6b 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
` (35 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:10 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When the content of a commited file is unchanged and the attributes are changed,
Git may not detect that the next commit must treat the file as changed.
This happens when lstat() doesn't detect a change, since neither inode,
mtime nor size are changed.
Add a singe "Z" character to change the file size (and content).
When the files are compared later in checkout_files(), the "Z" is removed
before the comparison.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Changes since v5:
- send the whole series, now 10/10
- Removed the "will change in future" in one commit msg
- Don't leak the filer in 4/10
t/t0027-auto-crlf.sh | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
Changes since v6:
- Reword commit msg in 1/10
- Add SOB in 9/10
- Correct typos
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index f33962b..9fe539b 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -12,7 +12,7 @@ fi
compare_files () {
tr '\015\000' QN <"$1" >"$1".expect &&
- tr '\015\000' QN <"$2" >"$2".actual &&
+ tr '\015\000' QN <"$2" | tr -d 'Z' >"$2".actual &&
test_cmp "$1".expect "$2".actual &&
rm "$1".expect "$2".actual
}
@@ -114,6 +114,7 @@ commit_chk_wrnNNO () {
do
fname=${pfx}_$f.txt &&
cp $f $fname &&
+ printf Z >>"$fname" &&
git -c core.autocrlf=$crlf add $fname 2>/dev/null &&
git -c core.autocrlf=$crlf commit -m "commit_$fname" $fname >"${pfx}_$f.err" 2>&1
done
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6b 02/10] convert: allow core.autocrlf=input and core.eol=crlf
2016-03-07 22:34 ` Junio C Hamano
` (29 preceding siblings ...)
2016-04-24 15:10 ` [PATCH v6b 01/10] t0027: Make commit_chk_wrnNNO() reliable tboegi
@ 2016-04-24 15:11 ` tboegi
2016-04-24 15:11 ` [PATCH v6b 03/10] t0027: test cases for combined attributes tboegi
` (34 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Even though the configuration parser errors out when core.autocrlf
is set to 'input' when core.eol is set to 'crlf', there is no need
to do so, because the core.autocrlf setting trumps core.eol.
Allow all combinations of core.crlf and core.eol and document
that core.autocrlf overrides core.eol.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 6 +++---
config.c | 4 ----
2 files changed, 3 insertions(+), 7 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 42d2b50..155f988 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -337,9 +337,9 @@ core.quotePath::
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
+ files that have the `text` property set when core.autocrlf is false.
+ 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.
diff --git a/config.c b/config.c
index 4c92699..c8ac9c2 100644
--- a/config.c
+++ b/config.c
@@ -803,8 +803,6 @@ static int git_default_core_config(const char *var, const char *value)
if (!strcmp(var, "core.autocrlf")) {
if (value && !strcasecmp(value, "input")) {
- if (core_eol == EOL_CRLF)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
auto_crlf = AUTO_CRLF_INPUT;
return 0;
}
@@ -830,8 +828,6 @@ static int git_default_core_config(const char *var, const char *value)
core_eol = EOL_NATIVE;
else
core_eol = EOL_UNSET;
- if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
return 0;
}
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6b 03/10] t0027: test cases for combined attributes
2016-03-07 22:34 ` Junio C Hamano
` (30 preceding siblings ...)
2016-04-24 15:11 ` [PATCH v6b 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
@ 2016-04-24 15:11 ` tboegi
2016-04-24 15:11 ` [PATCH v6b 04/10] convert.c: ident + core.autocrlf didn't work tboegi
` (33 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Add more test cases for the not normalized files ("NNO"). The
"text" attribute is most important, use it as the first parameter.
"ident", if set, is the second paramater followed by the eol
attribute. The eol attribute overrides core.autocrlf, which
overrides core.eol.
indent is not yet used, this will be done in the next commit.
Use loops to test more combinations of attributes, like
"* text eol=crlf" or especially "*text=auto eol=crlf".
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t0027-auto-crlf.sh | 298 ++++++++++++++++++++++-----------------------------
1 file changed, 129 insertions(+), 169 deletions(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 9fe539b..fd5e326 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -52,14 +52,17 @@ create_gitattributes () {
create_NNO_files () {
for crlf in false true input
do
- for attr in "" auto text -text lf crlf
+ for attr in "" auto text -text
do
- pfx=NNO_${crlf}_attr_${attr} &&
- cp CRLF_mix_LF ${pfx}_LF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
- cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ for aeol in "" lf crlf
+ do
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ cp CRLF_mix_LF ${pfx}_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ done
done
done
}
@@ -100,16 +103,17 @@ commit_check_warn () {
}
commit_chk_wrnNNO () {
- crlf=$1
- attr=$2
- lfwarn=$3
- crlfwarn=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfwarn=$1 ; shift
+ crlfwarn=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
#Commit files on top of existing file
- create_gitattributes "$attr" &&
+ create_gitattributes "$attr" $aeol &&
for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
do
fname=${pfx}_$f.txt &&
@@ -122,19 +126,19 @@ commit_chk_wrnNNO () {
test_expect_success "commit NNO files crlf=$crlf attr=$attr LF" '
check_warning "$lfwarn" ${pfx}_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF" '
check_warning "$crlfwarn" ${pfx}_CRLF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_mix_LF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_mix_LF" '
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr LF_mix_cr" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf LF_mix_cr" '
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_nul" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_nul" '
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
'
}
@@ -163,6 +167,7 @@ stats_ascii () {
# contruct the attr/ returned by git ls-files --eol
# Take none (=empty), one or two args
+# convert.c: eol=XX overrides text=auto
attr_ascii () {
case $1,$2 in
-text,*) echo "-text" ;;
@@ -170,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text=auto eol=lf" ;;
- auto,crlf) echo "text=auto eol=crlf" ;;
+ auto,lf) echo "text eol=lf" ;;
+ auto,crlf) echo "text eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -196,28 +201,29 @@ check_files_in_repo () {
}
check_in_repo_NNO () {
- crlf=$1
- attr=$2
- lfname=$3
- crlfname=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}_
- test_expect_success "compare_files $lfname ${pfx}LF.txt" '
- compare_files $lfname ${pfx}LF.txt
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfname=$1 ; shift
+ crlfname=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ test_expect_success "compare_files $lfname ${pfx}_LF.txt" '
+ compare_files $lfname ${pfx}_LF.txt
'
- test_expect_success "compare_files $crlfname ${pfx}CRLF.txt" '
- compare_files $crlfname ${pfx}CRLF.txt
+ test_expect_success "compare_files $crlfname ${pfx}_CRLF.txt" '
+ compare_files $crlfname ${pfx}_CRLF.txt
'
- test_expect_success "compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt" '
- compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt
+ test_expect_success "compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt" '
+ compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt
'
- test_expect_success "compare_files $lfmixcr ${pfx}LF_mix_CR.txt" '
- compare_files $lfmixcr ${pfx}LF_mix_CR.txt
+ test_expect_success "compare_files $lfmixcr ${pfx}_LF_mix_CR.txt" '
+ compare_files $lfmixcr ${pfx}_LF_mix_CR.txt
'
- test_expect_success "compare_files $crlfnul ${pfx}CRLF_nul.txt" '
- compare_files $crlfnul ${pfx}CRLF_nul.txt
+ test_expect_success "compare_files $crlfnul ${pfx}_CRLF_nul.txt" '
+ compare_files $crlfnul ${pfx}_CRLF_nul.txt
'
}
@@ -232,7 +238,7 @@ checkout_files () {
lfmixcrlf=$1 ; shift
lfmixcr=$1 ; shift
crlfnul=$1 ; shift
- create_gitattributes "$attr" "$ident" &&
+ create_gitattributes "$attr" $ident $aeol &&
git config core.autocrlf $crlf &&
pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
@@ -245,7 +251,7 @@ checkout_files () {
fi
done
- test_expect_success "ls-files --eol attr=$attr $ident $aeol core.autocrlf=$crlf core.eol=$ceol" '
+ test_expect_success "ls-files --eol attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol" '
test_when_finished "rm expect actual" &&
sort <<-EOF >expect &&
i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
@@ -260,19 +266,19 @@ checkout_files () {
sort >actual &&
test_cmp expect actual
'
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
compare_ws_file $pfx $lfname crlf_false_attr__LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
compare_ws_file $pfx $crlfname crlf_false_attr__CRLF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
compare_ws_file $pfx $lfmixcrlf crlf_false_attr__CRLF_mix_LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
compare_ws_file $pfx $lfmixcr crlf_false_attr__LF_mix_CR.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
compare_ws_file $pfx $crlfnul crlf_false_attr__LF_nul.txt
"
}
@@ -386,31 +392,31 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
-commit_chk_wrnNNO false "" "" "" "" "" ""
-commit_chk_wrnNNO true "" "LF_CRLF" "" "" "" ""
-commit_chk_wrnNNO input "" "" "" "" "" ""
-
+# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+commit_chk_wrnNNO "" "" false "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO false "auto" "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO true "auto" "LF_CRLF" "" "LF_CRLF" "" ""
-commit_chk_wrnNNO input "auto" "" "CRLF_LF" "CRLF_LF" "" ""
+commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-commit_chk_wrnNNO false "text" "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO true "text" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "text" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-
-commit_chk_wrnNNO false "-text" "" "" "" "" ""
-commit_chk_wrnNNO true "-text" "" "" "" "" ""
-commit_chk_wrnNNO input "-text" "" "" "" "" ""
-
-commit_chk_wrnNNO false "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO true "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO input "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
+for crlf in true false input
+do
+ commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+done
-commit_chk_wrnNNO false "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO true "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
test_expect_success 'create files cleanup' '
rm -f *.txt &&
@@ -441,24 +447,20 @@ test_expect_success 'commit -text' '
check_files_in_repo input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
'
-# attr LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
-check_in_repo_NNO false "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "auto" LF LF LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO true "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO input "text" LF LF LF LF_mix_CR LF_nul
-
-check_in_repo_NNO false "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-
+for crlf in true false input
+do
+ # attr aeol LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
+ check_in_repo_NNO "" "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+done
################################################################################
# Check how files in the repo are changed when they are checked out
# How to read the table below:
@@ -490,89 +492,47 @@ LFNUL=LF_nul
fi
export CRLF_MIX_LF_CR MIX NL
-checkout_files "" "" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true "" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true crlf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true lf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true native CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true "" CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true lf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true native CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-
-for id in "" ident;
+# Same handling with and without ident
+for id in ""
do
- checkout_files "crlf" "$id" "" false "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "lf" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "-text" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ for ceol in lf crlf native
+ do
+ for crlf in true false input
+ do
+ # -text overrides core.autocrlf and core.eol
+ # text and eol=crlf or eol=lf override core.autocrlf and core.eol
+ checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # currently the same as text, eol=XXX
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+
+ # core.autocrlf false, different core.eol
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # core.autocrlf true
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf = true overrides core.eol
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # text: core.autocrlf = input overrides core.eol
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text=auto + eol=XXX
+ done
+ # text: core.autocrlf=false uses core.eol
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ # auto: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6b 04/10] convert.c: ident + core.autocrlf didn't work
2016-03-07 22:34 ` Junio C Hamano
` (31 preceding siblings ...)
2016-04-24 15:11 ` [PATCH v6b 03/10] t0027: test cases for combined attributes tboegi
@ 2016-04-24 15:11 ` tboegi
2016-04-24 15:11 ` [PATCH v6b 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
` (32 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When the ident attributes is set, get_stream_filter() did not obey
core.autocrlf=true, and the file was checked out with LF.
Change the rule when a streaming filter can be used:
- if an external filter is specified, don't use a stream filter.
- if the worktree eol is CRLF and "auto" is active, don't use a stream filter.
- Otherwise the stream filter can be used.
Add test cases in t0027.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 19 +++++++------------
t/t0027-auto-crlf.sh | 2 +-
2 files changed, 8 insertions(+), 13 deletions(-)
diff --git a/convert.c b/convert.c
index f524b8d..b1614bf 100644
--- a/convert.c
+++ b/convert.c
@@ -1380,27 +1380,22 @@ static struct stream_filter *ident_filter(const unsigned char *sha1)
struct stream_filter *get_stream_filter(const char *path, const unsigned char *sha1)
{
struct conv_attrs ca;
- enum crlf_action crlf_action;
struct stream_filter *filter = NULL;
convert_attrs(&ca, path);
-
if (ca.drv && (ca.drv->smudge || ca.drv->clean))
- return filter;
+ return NULL;
+
+ if (ca.crlf_action == CRLF_AUTO || ca.crlf_action == CRLF_AUTO_CRLF)
+ return NULL;
if (ca.ident)
filter = ident_filter(sha1);
- crlf_action = ca.crlf_action;
-
- if ((crlf_action == CRLF_BINARY) ||
- crlf_action == CRLF_AUTO_INPUT ||
- (crlf_action == CRLF_TEXT_INPUT))
- filter = cascade_filter(filter, &null_filter_singleton);
-
- else if (output_eol(crlf_action) == EOL_CRLF &&
- !(crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_CRLF))
+ if (output_eol(ca.crlf_action) == EOL_CRLF)
filter = cascade_filter(filter, lf_to_crlf_filter());
+ else
+ filter = cascade_filter(filter, &null_filter_singleton);
return filter;
}
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index fd5e326..9372589 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -493,7 +493,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6b 05/10] read-cache: factor out get_sha1_from_index() helper
2016-03-07 22:34 ` Junio C Hamano
` (32 preceding siblings ...)
2016-04-24 15:11 ` [PATCH v6b 04/10] convert.c: ident + core.autocrlf didn't work tboegi
@ 2016-04-24 15:11 ` tboegi
2016-04-24 15:11 ` [PATCH v6b 06/10] convert.c: stream and early out tboegi
` (31 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Factor out the retrieval of the sha1 for a given path in
read_blob_data_from_index() into the function get_sha1_from_index().
This will be used in the next commit, when convert.c can do the
analyze for "text=auto" without slurping the whole blob into memory
at once.
Add a wrapper definition get_sha1_from_cache().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
cache.h | 3 +++
read-cache.c | 29 ++++++++++++++++++-----------
2 files changed, 21 insertions(+), 11 deletions(-)
diff --git a/cache.h b/cache.h
index 2711048..867ceb5 100644
--- a/cache.h
+++ b/cache.h
@@ -379,6 +379,7 @@ extern void free_name_hash(struct index_state *istate);
#define unmerge_cache_entry_at(at) unmerge_index_entry_at(&the_index, at)
#define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)
#define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))
+#define get_sha1_from_cache(path) get_sha1_from_index (&the_index, (path))
#endif
enum object_type {
@@ -1040,6 +1041,8 @@ static inline void *read_sha1_file(const unsigned char *sha1, enum object_type *
return read_sha1_file_extended(sha1, type, size, LOOKUP_REPLACE_OBJECT);
}
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path);
+
/*
* This internal function is only declared here for the benefit of
* lookup_replace_object(). Please do not call it directly.
diff --git a/read-cache.c b/read-cache.c
index d9fb78b..a3ef967 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -2263,13 +2263,27 @@ int index_name_is_other(const struct index_state *istate, const char *name,
void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
{
- int pos, len;
+ const unsigned char *sha1;
unsigned long sz;
enum object_type type;
void *data;
- len = strlen(path);
- pos = index_name_pos(istate, path, len);
+ sha1 = get_sha1_from_index(istate, path);
+ if (!sha1)
+ return NULL;
+ data = read_sha1_file(sha1, &type, &sz);
+ if (!data || type != OBJ_BLOB) {
+ free(data);
+ return NULL;
+ }
+ if (size)
+ *size = sz;
+ return data;
+}
+
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path)
+{
+ int pos = index_name_pos(istate, path, strlen(path));
if (pos < 0) {
/*
* We might be in the middle of a merge, in which
@@ -2285,14 +2299,7 @@ void *read_blob_data_from_index(struct index_state *istate, const char *path, un
}
if (pos < 0)
return NULL;
- data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
- if (!data || type != OBJ_BLOB) {
- free(data);
- return NULL;
- }
- if (size)
- *size = sz;
- return data;
+ return (istate->cache[pos]->sha1);
}
void stat_validity_clear(struct stat_validity *sv)
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6b 06/10] convert.c: stream and early out
2016-03-07 22:34 ` Junio C Hamano
` (33 preceding siblings ...)
2016-04-24 15:11 ` [PATCH v6b 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
@ 2016-04-24 15:11 ` tboegi
2016-04-24 15:11 ` [PATCH v6b 07/10] convert: unify the "auto" handling of CRLF tboegi
` (30 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When statistics are done for the autocrlf handling, the search in
the content can be stopped, if e.g
- a search for binary is done, and a NUL character is found
- a search for CRLF is done, and the first CRLF is found.
Similar when statistics for binary vs non-binary are gathered:
Whenever a lone CR or NUL is found, the search can be aborted.
When checking out files in "auto" mode, any file that has a "lone CR"
or a CRLF will not be converted, so the search can be aborted early.
Add the new bit, CONVERT_STAT_BITS_ANY_CR,
which is set for either lone CR or CRLF.
Many binary files have a NUL very early (within the first few bytes,
latest within the first 1..2K).
It is often not necessary to load the whole content of a file or blob
into memory.
Use a streaming handling for blobs and files in the worktree.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 159 ++++++++++++++++++++++++++++++++++++++++----------------------
1 file changed, 103 insertions(+), 56 deletions(-)
diff --git a/convert.c b/convert.c
index b1614bf..24ab095 100644
--- a/convert.c
+++ b/convert.c
@@ -3,6 +3,7 @@
#include "run-command.h"
#include "quote.h"
#include "sigchain.h"
+#include "streaming.h"
/*
* convert.c - convert a file when checking it out and checking it in.
@@ -13,10 +14,10 @@
* translation when the "text" attribute or "auto_crlf" option is set.
*/
-/* Stat bits: When BIN is set, the txt bits are unset */
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
+#define CONVERT_STAT_BITS_ANY_CR 0x8
enum crlf_action {
CRLF_UNDEFINED,
@@ -31,30 +32,36 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned nul, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonecr, lonelf, crlf;
/* These are just approximations! */
unsigned printable, nonprintable;
};
-static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
+static void do_gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
{
unsigned long i;
- memset(stats, 0, sizeof(*stats));
-
+ if (!buf || !size)
+ return;
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
+ stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
stats->crlf++;
i++;
- } else
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
+ } else {
stats->lonecr++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+ }
continue;
}
if (c == '\n') {
stats->lonelf++;
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_LF;
continue;
}
if (c == 127)
@@ -67,7 +74,7 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
stats->printable++;
break;
case 0:
- stats->nul++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
/* fall through */
default:
stats->nonprintable++;
@@ -75,6 +82,8 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
}
else
stats->printable++;
+ if (stats->stat_bits & earlyout)
+ break; /* We found what we have been searching for */
}
/* If file ends with EOF then don't count this EOF as non-printable. */
@@ -86,41 +95,62 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
* The same heuristics as diff.c::mmfile_is_binary()
* We treat files with bare CR as binary
*/
-static int convert_is_binary(unsigned long size, const struct text_stat *stats)
+static void convert_nonprintable(struct text_stat *stats)
{
- if (stats->lonecr)
- return 1;
- if (stats->nul)
- return 1;
if ((stats->printable >> 7) < stats->nonprintable)
- return 1;
- return 0;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+}
+
+static void gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
+{
+ memset(stats, 0, sizeof(*stats));
+ do_gather_stats(buf, size, stats, earlyout);
+ convert_nonprintable(stats);
}
-static unsigned int gather_convert_stats(const char *data, unsigned long size)
+
+static unsigned get_convert_stats_sha1(unsigned const char *sha1,
+ unsigned earlyout)
{
+ struct git_istream *st;
struct text_stat stats;
- int ret = 0;
- if (!data || !size)
- return 0;
- gather_stats(data, size, &stats);
- if (convert_is_binary(size, &stats))
- ret |= CONVERT_STAT_BITS_BIN;
- if (stats.crlf)
- ret |= CONVERT_STAT_BITS_TXT_CRLF;
- if (stats.lonelf)
- ret |= CONVERT_STAT_BITS_TXT_LF;
+ enum object_type type;
+ unsigned long sz;
- return ret;
+ if (!sha1)
+ return 0;
+ memset(&stats, 0, sizeof(stats));
+ st = open_istream(sha1, &type, &sz, NULL);
+ if (!st) {
+ return 0;
+ }
+ if (type != OBJ_BLOB)
+ goto close_and_exit_i;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read_istream(st, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+close_and_exit_i:
+ close_istream(st);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
}
-static const char *gather_convert_stats_ascii(const char *data, unsigned long size)
+static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned int convert_stats = gather_convert_stats(data, size);
-
+ unsigned mask = CONVERT_STAT_BITS_TXT_LF |
+ CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats) {
+ switch (convert_stats & mask) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -132,24 +162,45 @@ static const char *gather_convert_stats_ascii(const char *data, unsigned long si
}
}
+static unsigned get_convert_stats_wt(const char *path)
+{
+ struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ int fd;
+ memset(&stats, 0, sizeof(stats));
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ return 0;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read(fd, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+ close(fd);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
+}
+
const char *get_cached_convert_stats_ascii(const char *path)
{
- const char *ret;
- unsigned long sz;
- void *data = read_blob_data_from_cache(path, &sz);
- ret = gather_convert_stats_ascii(data, sz);
- free(data);
- return ret;
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
}
const char *get_wt_convert_stats_ascii(const char *path)
{
- const char *ret = "";
- struct strbuf sb = STRBUF_INIT;
- if (strbuf_read_file(&sb, path, 0) >= 0)
- ret = gather_convert_stats_ascii(sb.buf, sb.len);
- strbuf_release(&sb);
- return ret;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_wt(path);
+ return convert_stats_ascii(convert_stats);
}
static int text_eol_is_crlf(void)
@@ -219,16 +270,10 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
static int has_cr_in_index(const char *path)
{
- unsigned long sz;
- void *data;
- int has_cr;
-
- data = read_blob_data_from_cache(path, &sz);
- if (!data)
- return 0;
- has_cr = memchr(data, '\r', sz) != NULL;
- free(data);
- return has_cr;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_ANY_CR);
+ return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -249,10 +294,10 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
@@ -309,11 +354,13 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
+
if (!len || output_eol(crlf_action) != EOL_CRLF)
return 0;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, earlyout);
/* No "naked" LF? Nothing to convert, regardless. */
if (!stats.lonelf)
@@ -327,7 +374,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
}
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
}
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6b 07/10] convert: unify the "auto" handling of CRLF
2016-03-07 22:34 ` Junio C Hamano
` (34 preceding siblings ...)
2016-04-24 15:11 ` [PATCH v6b 06/10] convert.c: stream and early out tboegi
@ 2016-04-24 15:11 ` tboegi
2016-04-24 15:11 ` [PATCH v6b 08/10] convert.c: more safer crlf handling with text attribute tboegi
` (29 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Before this change,
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
would have the same effect as
$ echo "* text" >.gitattributes
$ git config core.eol crlf
Since the 'eol' attribute had higher priority than 'text=auto', this may
corrupt binary files and is not what users expect to happen.
Make the 'eol' attribute to obey 'text=auto', and now
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
behaves the same as
$ echo "* text=auto" >.gitattributes
$ git config core.eol crlf
In other words,
$ echo "* text=auto eol=crlf" >.gitattributes
has the same effect as
$ git config core.autocrlf true
and
$ echo "* text=auto eol=lf" >.gitattributes
has the same effect as
$ git config core.autocrlf input
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 14 +++++++-------
Documentation/gitattributes.txt | 15 +++++++++------
convert.c | 42 +++++++++++++++++++++--------------------
convert.h | 3 ++-
t/t0025-crlf-auto.sh | 4 ++--
t/t0027-auto-crlf.sh | 32 +++++++++++++++----------------
t/t6038-merge-text-auto.sh | 23 ++++++++++++++--------
7 files changed, 73 insertions(+), 60 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 155f988..117c2f3 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -389,13 +389,13 @@ 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',
+ Setting this variable to "true" is the same as setting
+ the `text` attribute to "auto" on all files and core.eol to "crlf".
+ Set to true if you want to have `CRLF` line endings in your
+ working directory and the repository has LF line endings.
+ Text files are guaranteed not to be normalized: files that contain
+ `CRLF` in the repository will not be touched.
+ This variable can be set to 'input',
in which case no output conversion is performed.
core.symlinks::
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index e3b1de8..d7a124b 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -115,6 +115,7 @@ 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.eol` configuration variable for all text files.
+Note that `core.autocrlf` overrides `core.eol`
Set::
@@ -130,8 +131,9 @@ Unset::
Set to string value "auto"::
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.
+ end-of-line conversion. If Git decides that the content is
+ text, its line endings are converted to LF on checkin.
+ When the file has been commited with CRLF, no conversion is done.
Unspecified::
@@ -146,7 +148,7 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line normalization without any
+working directory. It enables end-of-line conversion without any
content checks, effectively setting the `text` attribute.
Set to string value "crlf"::
@@ -186,9 +188,10 @@ the working directory, and prevent .jpg files from being normalized
regardless of their content.
------------------------
+* text=auto
*.txt text
-*.vcproj eol=crlf
-*.sh eol=lf
+*.vcproj text eol=crlf
+*.sh text eol=lf
*.jpg -text
------------------------
@@ -198,7 +201,7 @@ 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.
+config variable "core.autocrlf" without using any attributes.
------------------------
[core]
diff --git a/convert.c b/convert.c
index 24ab095..3782172 100644
--- a/convert.c
+++ b/convert.c
@@ -227,7 +227,9 @@ static enum eol output_eol(enum crlf_action crlf_action)
return EOL_LF;
case CRLF_UNDEFINED:
case CRLF_AUTO_CRLF:
+ return EOL_CRLF;
case CRLF_AUTO_INPUT:
+ return EOL_LF;
case CRLF_TEXT:
case CRLF_AUTO:
/* fall through */
@@ -299,17 +301,15 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
-
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /*
- * 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 the file in the index has any CR in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ if (checksafe == SAFE_CRLF_RENORMALIZE)
+ checksafe = SAFE_CRLF_FALSE;
+ else if (has_cr_in_index(path))
+ return 0;
}
-
check_safe_crlf(path, crlf_action, &stats, checksafe);
/* Optimization: No CRLF? Nothing to convert, regardless. */
@@ -367,12 +367,10 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
- }
+ /* If we have any CR or CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (stats.lonecr || stats.crlf )
+ return 0;
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
@@ -833,7 +831,11 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
ca->drv = git_path_check_convert(ccheck + 2);
if (ca->crlf_action != CRLF_BINARY) {
enum eol eol_attr = git_path_check_eol(ccheck + 3);
- if (eol_attr == EOL_LF)
+ if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_LF)
+ ca->crlf_action = CRLF_AUTO_INPUT;
+ else if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_CRLF)
+ ca->crlf_action = CRLF_AUTO_CRLF;
+ else if (eol_attr == EOL_LF)
ca->crlf_action = CRLF_TEXT_INPUT;
else if (eol_attr == EOL_CRLF)
ca->crlf_action = CRLF_TEXT_CRLF;
@@ -892,9 +894,9 @@ const char *get_convert_attr_ascii(const char *path)
case CRLF_AUTO:
return "text=auto";
case CRLF_AUTO_CRLF:
- return "text=auto eol=crlf"; /* This is not supported yet */
+ return "text=auto eol=crlf";
case CRLF_AUTO_INPUT:
- return "text=auto eol=lf"; /* This is not supported yet */
+ return "text=auto eol=lf";
}
return "";
}
@@ -996,7 +998,7 @@ int renormalize_buffer(const char *path, const char *src, size_t len, struct str
src = dst->buf;
len = dst->len;
}
- return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_FALSE);
+ return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_RENORMALIZE);
}
/*****************************************************************
diff --git a/convert.h b/convert.h
index ccf436b..81b6cdf 100644
--- a/convert.h
+++ b/convert.h
@@ -7,7 +7,8 @@
enum safe_crlf {
SAFE_CRLF_FALSE = 0,
SAFE_CRLF_FAIL = 1,
- SAFE_CRLF_WARN = 2
+ SAFE_CRLF_WARN = 2,
+ SAFE_CRLF_RENORMALIZE = 4
};
extern enum safe_crlf safe_crlf;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index c164b46..d0bee08 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -114,7 +114,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
+test_expect_success 'text=auto, autocrlf=true does not normalize CRLF files' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
git config core.autocrlf true &&
@@ -126,7 +126,7 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
LFonlydiff=$(git diff LFonly) &&
CRLFonlydiff=$(git diff CRLFonly) &&
LFwithNULdiff=$(git diff LFwithNUL) &&
- test -z "$LFonlydiff" -a -n "$CRLFonlydiff" -a -z "$LFwithNULdiff"
+ test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 9372589..8367d0b 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -175,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text eol=lf" ;;
- auto,crlf) echo "text eol=crlf" ;;
+ auto,lf) echo "text=auto eol=lf" ;;
+ auto,crlf) echo "text=auto eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -397,10 +397,9 @@ commit_chk_wrnNNO "" "" false "" "" "" ""
commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
-commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-
+commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
@@ -408,8 +407,8 @@ do
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
done
@@ -454,9 +453,9 @@ do
check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
@@ -493,7 +492,8 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in "" ident
+#for id in "" ident
+for id in ""
do
for ceol in lf crlf native
do
@@ -509,7 +509,7 @@ do
checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
@@ -517,7 +517,7 @@ do
# core.autocrlf true
checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
@@ -531,8 +531,8 @@ do
checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 85c10b0..33b77ee 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -16,6 +16,13 @@ test_description='CRLF merge conflict across text=auto change
test_have_prereq SED_STRIPS_CR && SED_OPTIONS=-b
+compare_files () {
+ tr '\015\000' QN <"$1" >"$1".expect &&
+ tr '\015\000' QN <"$2" >"$2".actual &&
+ test_cmp "$1".expect "$2".actual &&
+ rm "$1".expect "$2".actual
+}
+
test_expect_success setup '
git config core.autocrlf false &&
@@ -30,7 +37,7 @@ test_expect_success setup '
git branch side &&
echo "* text=auto" >.gitattributes &&
- touch file &&
+ echo first line >file &&
git add .gitattributes file &&
test_tick &&
git commit -m "normalize file" &&
@@ -81,7 +88,7 @@ test_expect_success 'Merge after setting text=auto' '
rm -f .gitattributes &&
git reset --hard a &&
git merge b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Merge addition of text=auto' '
@@ -99,7 +106,7 @@ test_expect_success 'Merge addition of text=auto' '
rm -f .gitattributes &&
git reset --hard b &&
git merge a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
@@ -121,7 +128,7 @@ test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
git reset --hard a &&
test_must_fail git merge b &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
@@ -143,7 +150,7 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
git reset --hard b &&
test_must_fail git merge a &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_failure 'checkout -m after setting text=auto' '
@@ -158,7 +165,7 @@ test_expect_failure 'checkout -m after setting text=auto' '
git reset --hard initial &&
git checkout a -- . &&
git checkout -m b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'checkout -m addition of text=auto' '
@@ -173,7 +180,7 @@ test_expect_failure 'checkout -m addition of text=auto' '
git reset --hard initial &&
git checkout b -- . &&
git checkout -m a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'cherry-pick patch from after text=auto was added' '
@@ -187,7 +194,7 @@ test_expect_failure 'cherry-pick patch from after text=auto was added' '
git reset --hard b &&
test_must_fail git cherry-pick a >err 2>&1 &&
grep "[Nn]othing added" err &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Test delete/normalize conflict' '
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6b 08/10] convert.c: more safer crlf handling with text attribute
2016-03-07 22:34 ` Junio C Hamano
` (35 preceding siblings ...)
2016-04-24 15:11 ` [PATCH v6b 07/10] convert: unify the "auto" handling of CRLF tboegi
@ 2016-04-24 15:11 ` tboegi
2016-04-24 15:11 ` [PATCH v6b 09/10] t6038; use crlf on all platforms tboegi
` (28 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
This patch extends the work done in commit c480539:
"Make it work also for un-normalized repositories". Make sure that CRLF
can be converted round trip, or don't convert them at all.
The old handling would treat a file as unchanged after checkout,
as long as it is not touched in the work tree and mtime matches the value
recorded in the index.
When the mtime is changed in the working tree, or the inode is changed,
the file is reported as modified.
The following sequence is now handled reproducable:
$ git init
$ printf "line1\r\n" >file.bat
$ git add file.bat
$ git commit -m "Add file with CRLF" file.bat
$ echo "*.bat text eol=crlf" >.gitattributes
$ git commit -m "bat files should have CRLF"
$ git status
# nothing to commit, working directory clean
$ git push <upstream>
$ printf "newline\r\n" >>file.bat
$ mv file.bat file.sav
$ git checkout file.bat
$ git status
#modified: file.bat
The new handling makes sure that after running "git reset --hard".
"git status" reports the working tree as clean regarding CRLF conversion.
It makes sure that the Git-internal eol conversion is
doing roundtrip. A user can still write an external smudge/clean filter
outside Git, which doesn't do a roundtrip and the working directory is
not clean.
The functionality of has_cr_in_index() is turned into has_crlf_in_index(),
and the function is integrated into would_convert_crlf_at_commit().
Check for CRLF in the index instead of CR, the bit CONVERT_STAT_BITS_ANY_CR
is no longer used and removed, as well as "lonecr" in struct text_stat.
Rewrite check_safe_crlf() in convert.c to simulate checkin-checkout,
to detect whether any line endings are converted.
Add a warning, similar to the CRLF-LF replacement, when a file is commited,
and after the next checkout the line endings are not what they should be.
Modify the lf_to_crlf_filter:
Files with LF are converted into CRLF, file with CRLF are not changed.
Files with mixed line endings are not converted, the filter fails, and Git
falls back to the non-streaming handling, see write_entry().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/gitattributes.txt | 19 ++--
convert.c | 233 +++++++++++++++++++++++++---------------
t/t0025-crlf-auto.sh | 8 +-
t/t0027-auto-crlf.sh | 92 ++++++++--------
4 files changed, 212 insertions(+), 140 deletions(-)
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index d7a124b..836461d 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -110,7 +110,7 @@ repository upon 'git add' and 'git commit'.
`text`
^^^^^^
-This attribute enables and controls end-of-line normalization. When a
+This attribute enables and controls end-of-line conversion. 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
@@ -120,8 +120,11 @@ Note that `core.autocrlf` overrides `core.eol`
Set::
Setting the `text` attribute on a path enables end-of-line
- normalization and marks the path as a text file. End-of-line
+ conversion and marks the path as a text file. End-of-line
conversion takes place without guessing the content type.
+ Files that have been commited with CRLF before the text attribute
+ is set and commited are not normalized. No end-of-line conversion
+ is done at checkout or checkin.
Unset::
@@ -131,9 +134,9 @@ Unset::
Set to string value "auto"::
When `text` is set to "auto", the path is marked for automatic
- end-of-line conversion. If Git decides that the content is
- text, its line endings are converted to LF on checkin.
- When the file has been commited with CRLF, no conversion is done.
+ end-of-line normalization. If Git decides that the content is
+ text, and the path has no CRLF in the index,
+ its line endings are converted to LF on checkin.
Unspecified::
@@ -148,8 +151,10 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line conversion without any
-content checks, effectively setting the `text` attribute.
+working directory. It sets the `text` attribute, unless `text=auto`
+is specified.
+When the file had been commited with CRLF in the index, no conversion
+is done at checkout or commit.
Set to string value "crlf"::
diff --git a/convert.c b/convert.c
index 3782172..8d4c42a 100644
--- a/convert.c
+++ b/convert.c
@@ -17,7 +17,8 @@
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
-#define CONVERT_STAT_BITS_ANY_CR 0x8
+
+#define CONVERT_STAT_BITS_MIXED (CONVERT_STAT_BITS_TXT_LF | CONVERT_STAT_BITS_TXT_CRLF)
enum crlf_action {
CRLF_UNDEFINED,
@@ -32,7 +33,7 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned stat_bits, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonelf;
/* These are just approximations! */
unsigned printable, nonprintable;
@@ -48,13 +49,10 @@ static void do_gather_stats(const char *buf, unsigned long size,
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
- stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
- stats->crlf++;
i++;
stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
} else {
- stats->lonecr++;
stats->stat_bits |= CONVERT_STAT_BITS_BIN;
}
continue;
@@ -135,7 +133,7 @@ static unsigned get_convert_stats_sha1(unsigned const char *sha1,
if (!readlen)
break;
do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
- if (stats.stat_bits & earlyout)
+ if ((stats.stat_bits & earlyout) == earlyout)
break; /* We found what we have been searching for */
}
close_and_exit_i:
@@ -146,11 +144,9 @@ close_and_exit_i:
static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned mask = CONVERT_STAT_BITS_TXT_LF |
- CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats & mask) {
+ switch (convert_stats) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -162,7 +158,16 @@ static const char *convert_stats_ascii(unsigned convert_stats)
}
}
-static unsigned get_convert_stats_wt(const char *path)
+const char *get_cached_convert_stats_ascii(const char *path)
+{
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
+}
+
+const char *get_wt_convert_stats_ascii(const char *path)
{
struct text_stat stats;
unsigned earlyout = CONVERT_STAT_BITS_BIN;
@@ -184,23 +189,7 @@ static unsigned get_convert_stats_wt(const char *path)
}
close(fd);
convert_nonprintable(&stats);
- return stats.stat_bits;
-}
-
-const char *get_cached_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- unsigned earlyout = CONVERT_STAT_BITS_BIN;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- earlyout);
- return convert_stats_ascii(convert_stats);
-}
-
-const char *get_wt_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_wt(path);
- return convert_stats_ascii(convert_stats);
+ return convert_stats_ascii(stats.stat_bits);
}
static int text_eol_is_crlf(void)
@@ -239,43 +228,95 @@ static enum eol output_eol(enum crlf_action crlf_action)
return core_eol;
}
+static int would_convert_lf_at_checkout(unsigned convert_stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ if (output_eol(crlf_action) != EOL_CRLF)
+ return 0;
+
+ /* No "naked" LF? Nothing to convert, regardless. */
+ if (!convert_stats & CONVERT_STAT_BITS_TXT_LF)
+ return 0;
+
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ /* auto: binary files are not converted */
+ if (convert_stats & CONVERT_STAT_BITS_BIN)
+ return 0;
+ }
+ /* If we have any CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+
+}
+
+static int would_convert_crlf_at_commit(const char * path,
+ const struct text_stat *stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ unsigned stat_bits_index;
+ /* No CRLF? Nothing to convert, regardless. */
+ if (!(stats->stat_bits & CONVERT_STAT_BITS_TXT_CRLF))
+ return 0;
+ /*
+ * If the file in the index has any CRLF in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ stat_bits_index = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_TXT_CRLF);
+ if (stat_bits_index & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+}
+
static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
- struct text_stat *stats, enum safe_crlf checksafe)
+ enum safe_crlf checksafe,
+ unsigned convert_stats, unsigned new_convert_stats)
{
+ enum eol new_eol = output_eol(crlf_action);
+ const char *err_warn_msg = NULL;
if (!checksafe)
return;
-
- if (output_eol(crlf_action) == EOL_LF) {
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
/*
* 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.\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 (output_eol(crlf_action) == EOL_CRLF) {
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if (convert_stats & CONVERT_STAT_BITS_TXT_LF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_LF)) {
/*
* CRLFs would be added by checkout:
* check if we have "naked" LFs
*/
- if (stats->lonelf) {
- if (checksafe == SAFE_CRLF_WARN)
- 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);
- }
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if ((new_convert_stats & CONVERT_STAT_BITS_MIXED) == CONVERT_STAT_BITS_MIXED)
+ err_warn_msg = "mixed eol";
+ else if (new_eol == EOL_LF && new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ err_warn_msg = "CRLF";
+
+ if (err_warn_msg) {
+ if (checksafe == SAFE_CRLF_WARN)
+ warning("%s will be present after commit and checkout in %s.",
+ err_warn_msg, path);
+ else
+ die("%s will be present after commit and checkout in %s",
+ err_warn_msg, path);
}
-}
-
-static int has_cr_in_index(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- CONVERT_STAT_BITS_ANY_CR);
- return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -284,7 +325,7 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
{
struct text_stat stats;
char *dst;
-
+ int convert_crlf;
if (crlf_action == CRLF_BINARY ||
(src && !len))
return 0;
@@ -296,24 +337,42 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
-
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
- /*
- * If the file in the index has any CR in it, do not convert.
- * This is the new safer autocrlf handling.
- */
- if (checksafe == SAFE_CRLF_RENORMALIZE)
- checksafe = SAFE_CRLF_FALSE;
- else if (has_cr_in_index(path))
- return 0;
+ } else {
+ gather_stats(src, len, &stats, 0);
+ }
+ if (checksafe == SAFE_CRLF_RENORMALIZE) {
+ convert_crlf = 1;
+ checksafe = SAFE_CRLF_FALSE;
+ } else {
+ convert_crlf = would_convert_crlf_at_commit(path, &stats, len,
+ crlf_action);
}
- check_safe_crlf(path, crlf_action, &stats, checksafe);
- /* Optimization: No CRLF? Nothing to convert, regardless. */
- if (!stats.crlf)
+ if (checksafe) {
+ unsigned convert_stats = stats.stat_bits;
+ unsigned new_convert_stats = convert_stats;
+ /* Simulate commit */
+ if (convert_crlf &&
+ (new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_LF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_CRLF;
+ }
+ /* Simulate checkout */
+ if (would_convert_lf_at_checkout(new_convert_stats,
+ len, crlf_action)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_CRLF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_LF;
+ }
+ check_safe_crlf(path, crlf_action, checksafe,
+ convert_stats, new_convert_stats);
+ }
+ if (!convert_crlf)
return 0;
/*
@@ -327,7 +386,9 @@ 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 (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
/*
* If we guessed, we already know we rejected a file with
* lone CR, and we can strip a CR without looking at what
@@ -354,28 +415,15 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
- unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
-
-
- if (!len || output_eol(crlf_action) != EOL_CRLF)
+ unsigned earlyout = 0; /* Need to count lonelf */
+ if (!len)
return 0;
gather_stats(src, len, &stats, earlyout);
-
- /* No "naked" LF? Nothing to convert, regardless. */
- if (!stats.lonelf)
+ if (!would_convert_lf_at_checkout(stats.stat_bits,
+ len, crlf_action))
return 0;
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
-
- if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
- return 0;
- }
-
/* are we "faking" in place editing ? */
if (src == buf->buf)
to_free = strbuf_detach(buf, NULL);
@@ -1067,6 +1115,8 @@ int is_null_stream_filter(struct stream_filter *filter)
struct lf_to_crlf_filter {
struct stream_filter filter;
unsigned has_held:1;
+ unsigned expanded_loneLF:1;
+ unsigned had_CRLF:1;
char held;
};
@@ -1107,7 +1157,12 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
char ch = input[i];
if (ch == '\n') {
- output[o++] = '\r';
+ if (!lf_to_crlf->had_CRLF) {
+ output[o++] = '\r';
+ lf_to_crlf->expanded_loneLF = 1;
+ }
+ if (was_cr)
+ lf_to_crlf->had_CRLF = 1;
} else if (was_cr) {
/*
* Previous round saw CR and it is not followed
@@ -1136,6 +1191,14 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
was_cr = 0;
output[o++] = ch;
+ if (lf_to_crlf->expanded_loneLF &&
+ lf_to_crlf->had_CRLF) {
+ /*
+ * Mixed EOL, round trip not possible.
+ */
+ return 1;
+ }
+
}
*osize_p -= o;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index d0bee08..b5f93e2 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 "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'crlf=true causes a CRLF file to be normalized' '
+test_expect_success 'crlf=true causes a CRLF file not to be normalized' '
# Backwards compatibility check
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
@@ -49,10 +49,10 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
-test_expect_success 'text=true causes a CRLF file to be normalized' '
+test_expect_success 'text=true causes a CRLF file not to be normalized' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
echo "CRLFonly text" > .gitattributes &&
@@ -61,7 +61,7 @@ test_expect_success 'text=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 8367d0b..a16e513 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -71,10 +71,14 @@ check_warning () {
case "$1" in
LF_CRLF) echo "warning: LF will be replaced by CRLF" >"$2".expect ;;
CRLF_LF) echo "warning: CRLF will be replaced by LF" >"$2".expect ;;
+ CRLF) echo "warning: CRLF will be present after commit and checkout" >"$2".expect ;;
+ mixed) echo "warning: mixed eol will be present after commit and checkout" >"$2".expect ;;
'') >"$2".expect ;;
*) echo >&2 "Illegal 1": "$1" ; return false ;;
esac
- grep "will be replaced by" "$2" | sed -e "s/\(.*\) in [^ ]*$/\1/" | uniq >"$2".actual
+ egrep "will be replaced by|will be present after commit" "$2" |
+ sed -e "s/\(.*\) in [^ ]*$/\1/" |
+ uniq >"$2".actual
test_cmp "$2".expect "$2".actual
}
@@ -169,7 +173,7 @@ stats_ascii () {
# Take none (=empty), one or two args
# convert.c: eol=XX overrides text=auto
attr_ascii () {
- case $1,$2 in
+ case "$1","$2" in
-text,*) echo "-text" ;;
text,) echo "text" ;;
text,lf) echo "text eol=lf" ;;
@@ -349,10 +353,12 @@ then
WILC=LF_CRLF
WICL=
WAMIX=LF_CRLF
+ Pcrlf=
else
WILC=
WICL=CRLF_LF
WAMIX=CRLF_LF
+ Pcrlf=CRLF
fi
# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
@@ -392,31 +398,32 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
commit_chk_wrnNNO "" "" false "" "" "" "" ""
-commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "" "" input "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "" "" input "" CRLF mixed "" ""
+
+commit_chk_wrnNNO "auto" "" false "$WILC" "$Pcrlf" mixed "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF mixed "" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$Pcrlf" mixed "$WILC" "$Pcrlf"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" mixed LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF mixed "" CRLF
+
-commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
- commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
- commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" mixed LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF mixed "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" mixed "" ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" mixed LF_CRLF ""
done
-commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
-commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
-
test_expect_success 'create files cleanup' '
rm -f *.txt &&
git -c core.autocrlf=false reset --hard
@@ -456,9 +463,9 @@ do
check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
done
################################################################################
# Check how files in the repo are changed when they are checked out
@@ -479,12 +486,10 @@ done
if test_have_prereq NATIVE_CRLF
then
-MIX_CRLF_LF=CRLF
MIX_LF_CR=CRLF_mix_CR
NL=CRLF
LFNUL=CRLF_nul
else
-MIX_CRLF_LF=CRLF_mix_LF
MIX_LF_CR=LF_mix_CR
NL=LF
LFNUL=LF_nul
@@ -492,8 +497,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-#for id in "" ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
@@ -501,38 +505,38 @@ do
do
# -text overrides core.autocrlf and core.eol
# text and eol=crlf or eol=lf override core.autocrlf and core.eol
- checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text
- checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
- checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
- checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# core.autocrlf true
- checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
- checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text=auto + eol=XXX
done
# text: core.autocrlf=false uses core.eol
- checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false "" $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
+ checkout_files text "$id" "" false native $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6b 09/10] t6038; use crlf on all platforms
2016-03-07 22:34 ` Junio C Hamano
` (36 preceding siblings ...)
2016-04-24 15:11 ` [PATCH v6b 08/10] convert.c: more safer crlf handling with text attribute tboegi
@ 2016-04-24 15:11 ` tboegi
2016-04-24 15:11 ` [PATCH v6b 10/10] ce_compare_data() did not respect conversion tboegi
` (27 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
t6038 uses different code, dependig if NATIVE_CRLF is set ot not.
When the native line endings are LF, merge.renormalize is not tested very well.
Change the test to always use CRLF by setting core.eol=crlf.
After doing so, the test fails:
rm '.gitattributes'
rm 'control_file'
rm 'file'
rm 'inert_file'
HEAD is now at 0d9ffb6 add line from b
error: addinfo_cache failed for path 'file'
file: unmerged (cbd69ec7cd12dd0989e853923867d94c8519aa52)
file: unmerged (ad55e240aeb42e0d9a0e18d6d8b02dd82ee3e527)
file: unmerged (99b633103c15c20cebebf821133ab526b0ff90b2)
fatal: git write-tree failed to write a tree
Merging:
0d9ffb6 add line from b
virtual a
found 1 common ancestor:
1c56df1 Initial
Auto-merging file
not ok 4 - Merge addition of text=auto
This will be addressed in the next commit.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t6038-merge-text-auto.sh | 37 +++++++++++--------------------------
1 file changed, 11 insertions(+), 26 deletions(-)
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 33b77ee..0108ead 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -25,6 +25,7 @@ compare_files () {
test_expect_success setup '
git config core.autocrlf false &&
+ git config core.eol crlf &&
echo first line | append_cr >file &&
echo first line >control_file &&
@@ -79,10 +80,8 @@ test_expect_success 'Merge after setting text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -97,10 +96,8 @@ test_expect_success 'Merge addition of text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -111,15 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected
- else
- echo first line >>expected &&
- echo same line >>expected &&
- echo ======= >>expected
- fi &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
+ echo ======= | append_cr >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -135,15 +126,9 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected
- else
- echo ======= >>expected &&
- echo first line >>expected &&
- echo same line >>expected
- fi &&
+ echo ======= | append_cr >>expected &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v6b 10/10] ce_compare_data() did not respect conversion
2016-03-07 22:34 ` Junio C Hamano
` (37 preceding siblings ...)
2016-04-24 15:11 ` [PATCH v6b 09/10] t6038; use crlf on all platforms tboegi
@ 2016-04-24 15:11 ` tboegi
2016-04-25 16:56 ` [PATCH v7 01/10] t0027: Make commit_chk_wrnNNO() reliable tboegi
` (26 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-24 15:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
We define the working tree file is clean if either:
* the result of running convert_to_git() on the working tree
contents matches what is in the index (because that would mean
doing another "git add" on the path is a no-op); OR
* the result of running convert_to_working_tree() on the content
in the index matches what is in the working tree (because that
would mean doing another "git checkout -f" on the path is a
no-op).
Add an extra check in ce_compare_data() in read_cache.c.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
read-cache.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++
t/t6038-merge-text-auto.sh | 14 +++++------
2 files changed, 68 insertions(+), 7 deletions(-)
diff --git a/read-cache.c b/read-cache.c
index a3ef967..48c4b31 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -156,17 +156,78 @@ void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
ce_mark_uptodate(ce);
}
+/*
+ * Compare the data in buf with the data in the file pointed by fd and
+ * return 0 if they are identical, and non-zero if they differ.
+ */
+static int compare_with_fd(const char *input, ssize_t len, int fd)
+{
+ for (;;) {
+ char buf[1024 * 16];
+ ssize_t chunk_len, read_len;
+
+ chunk_len = sizeof(buf) < len ? sizeof(buf) : len;
+ read_len = xread(fd, buf, chunk_len ? chunk_len : 1);
+
+ if (!read_len)
+ /* EOF on the working tree file */
+ return !len ? 0 : -1;
+
+ if (!len)
+ /* we expected there is nothing left */
+ return -1;
+
+ if (memcmp(buf, input, read_len))
+ return -1;
+ input += read_len;
+ len -= read_len;
+ }
+}
+
static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
{
int match = -1;
int fd = open(ce->name, O_RDONLY);
+ /*
+ * Would another "git add" on the path change what is in the
+ * index for the path?
+ */
if (fd >= 0) {
unsigned char sha1[20];
if (!index_fd(sha1, fd, st, OBJ_BLOB, ce->name, 0))
match = hashcmp(sha1, ce->sha1);
/* index_fd() closed the file descriptor already */
}
+ if (!match)
+ return match;
+
+ /*
+ * Would another "git checkout -f" out of the index change
+ * what is in the working tree file?
+ */
+ fd = open(ce->name, O_RDONLY);
+ if (fd >= 0) {
+ enum object_type type;
+ unsigned long size_long;
+ void *data = read_sha1_file(ce->sha1, &type, &size_long);
+
+ if (type == OBJ_BLOB) {
+ struct strbuf worktree = STRBUF_INIT;
+ if (convert_to_working_tree(ce->name, data,
+ size_long,
+ &worktree)) {
+ size_t size;
+ free(data);
+ data = strbuf_detach(&worktree, &size);
+ size_long = size;
+ }
+ if (!compare_with_fd(data, size_long, fd))
+ match = 0;
+ }
+ free(data);
+ close(fd);
+ }
return match;
}
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 0108ead..565daf3 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -108,9 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
+ echo ======= >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -121,14 +121,13 @@ test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
fuzz_conflict file >file.fuzzy &&
compare_files expected file.fuzzy
'
-
test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
+ echo ======= >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
@@ -138,6 +137,7 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
compare_files expected file.fuzzy
'
+
test_expect_failure 'checkout -m after setting text=auto' '
cat <<-\EOF >expected &&
first line
--
2.8.0.rc2.2.g1a4d45a.dirty
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 01/10] t0027: Make commit_chk_wrnNNO() reliable
2016-03-07 22:34 ` Junio C Hamano
` (38 preceding siblings ...)
2016-04-24 15:11 ` [PATCH v6b 10/10] ce_compare_data() did not respect conversion tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-25 19:15 ` Junio C Hamano
2016-04-25 16:56 ` [PATCH v7 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
` (25 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When the content of a commited file is unchanged and the attributes are changed,
Git may not detect that the next commit must treat the file as changed.
This happens when lstat() doesn't detect a change, since neither inode,
mtime nor size are changed.
Add a singe "Z" character to change the file size (and content).
When the files are compared later in checkout_files(), the "Z" is removed
before the comparison.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Change since v6b:
- Remove 2 sparse warnings, thanks Ramsay
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index f33962b..9fe539b 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -12,7 +12,7 @@ fi
compare_files () {
tr '\015\000' QN <"$1" >"$1".expect &&
- tr '\015\000' QN <"$2" >"$2".actual &&
+ tr '\015\000' QN <"$2" | tr -d 'Z' >"$2".actual &&
test_cmp "$1".expect "$2".actual &&
rm "$1".expect "$2".actual
}
@@ -114,6 +114,7 @@ commit_chk_wrnNNO () {
do
fname=${pfx}_$f.txt &&
cp $f $fname &&
+ printf Z >>"$fname" &&
git -c core.autocrlf=$crlf add $fname 2>/dev/null &&
git -c core.autocrlf=$crlf commit -m "commit_$fname" $fname >"${pfx}_$f.err" 2>&1
done
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 02/10] convert: allow core.autocrlf=input and core.eol=crlf
2016-03-07 22:34 ` Junio C Hamano
` (39 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 01/10] t0027: Make commit_chk_wrnNNO() reliable tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-25 16:56 ` [PATCH v7 03/10] t0027: test cases for combined attributes tboegi
` (24 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Even though the configuration parser errors out when core.autocrlf
is set to 'input' when core.eol is set to 'crlf', there is no need
to do so, because the core.autocrlf setting trumps core.eol.
Allow all combinations of core.crlf and core.eol and document
that core.autocrlf overrides core.eol.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 6 +++---
config.c | 4 ----
2 files changed, 3 insertions(+), 7 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 2cd6bdd..4a27ad4 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -337,9 +337,9 @@ core.quotePath::
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
+ files that have the `text` property set when core.autocrlf is false.
+ 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.
diff --git a/config.c b/config.c
index 9ba40bc..a6adc8b 100644
--- a/config.c
+++ b/config.c
@@ -803,8 +803,6 @@ static int git_default_core_config(const char *var, const char *value)
if (!strcmp(var, "core.autocrlf")) {
if (value && !strcasecmp(value, "input")) {
- if (core_eol == EOL_CRLF)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
auto_crlf = AUTO_CRLF_INPUT;
return 0;
}
@@ -830,8 +828,6 @@ static int git_default_core_config(const char *var, const char *value)
core_eol = EOL_NATIVE;
else
core_eol = EOL_UNSET;
- if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
return 0;
}
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 03/10] t0027: test cases for combined attributes
2016-03-07 22:34 ` Junio C Hamano
` (40 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-25 16:56 ` [PATCH v7 04/10] convert.c: ident + core.autocrlf didn't work tboegi
` (23 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Add more test cases for the not normalized files ("NNO"). The
"text" attribute is most important, use it as the first parameter.
"ident", if set, is the second paramater followed by the eol
attribute. The eol attribute overrides core.autocrlf, which
overrides core.eol.
indent is not yet used, this will be done in the next commit.
Use loops to test more combinations of attributes, like
"* text eol=crlf" or especially "*text=auto eol=crlf".
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t0027-auto-crlf.sh | 298 ++++++++++++++++++++++-----------------------------
1 file changed, 129 insertions(+), 169 deletions(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 9fe539b..fd5e326 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -52,14 +52,17 @@ create_gitattributes () {
create_NNO_files () {
for crlf in false true input
do
- for attr in "" auto text -text lf crlf
+ for attr in "" auto text -text
do
- pfx=NNO_${crlf}_attr_${attr} &&
- cp CRLF_mix_LF ${pfx}_LF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
- cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ for aeol in "" lf crlf
+ do
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ cp CRLF_mix_LF ${pfx}_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ done
done
done
}
@@ -100,16 +103,17 @@ commit_check_warn () {
}
commit_chk_wrnNNO () {
- crlf=$1
- attr=$2
- lfwarn=$3
- crlfwarn=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfwarn=$1 ; shift
+ crlfwarn=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
#Commit files on top of existing file
- create_gitattributes "$attr" &&
+ create_gitattributes "$attr" $aeol &&
for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
do
fname=${pfx}_$f.txt &&
@@ -122,19 +126,19 @@ commit_chk_wrnNNO () {
test_expect_success "commit NNO files crlf=$crlf attr=$attr LF" '
check_warning "$lfwarn" ${pfx}_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF" '
check_warning "$crlfwarn" ${pfx}_CRLF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_mix_LF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_mix_LF" '
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr LF_mix_cr" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf LF_mix_cr" '
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_nul" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_nul" '
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
'
}
@@ -163,6 +167,7 @@ stats_ascii () {
# contruct the attr/ returned by git ls-files --eol
# Take none (=empty), one or two args
+# convert.c: eol=XX overrides text=auto
attr_ascii () {
case $1,$2 in
-text,*) echo "-text" ;;
@@ -170,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text=auto eol=lf" ;;
- auto,crlf) echo "text=auto eol=crlf" ;;
+ auto,lf) echo "text eol=lf" ;;
+ auto,crlf) echo "text eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -196,28 +201,29 @@ check_files_in_repo () {
}
check_in_repo_NNO () {
- crlf=$1
- attr=$2
- lfname=$3
- crlfname=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}_
- test_expect_success "compare_files $lfname ${pfx}LF.txt" '
- compare_files $lfname ${pfx}LF.txt
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfname=$1 ; shift
+ crlfname=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ test_expect_success "compare_files $lfname ${pfx}_LF.txt" '
+ compare_files $lfname ${pfx}_LF.txt
'
- test_expect_success "compare_files $crlfname ${pfx}CRLF.txt" '
- compare_files $crlfname ${pfx}CRLF.txt
+ test_expect_success "compare_files $crlfname ${pfx}_CRLF.txt" '
+ compare_files $crlfname ${pfx}_CRLF.txt
'
- test_expect_success "compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt" '
- compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt
+ test_expect_success "compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt" '
+ compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt
'
- test_expect_success "compare_files $lfmixcr ${pfx}LF_mix_CR.txt" '
- compare_files $lfmixcr ${pfx}LF_mix_CR.txt
+ test_expect_success "compare_files $lfmixcr ${pfx}_LF_mix_CR.txt" '
+ compare_files $lfmixcr ${pfx}_LF_mix_CR.txt
'
- test_expect_success "compare_files $crlfnul ${pfx}CRLF_nul.txt" '
- compare_files $crlfnul ${pfx}CRLF_nul.txt
+ test_expect_success "compare_files $crlfnul ${pfx}_CRLF_nul.txt" '
+ compare_files $crlfnul ${pfx}_CRLF_nul.txt
'
}
@@ -232,7 +238,7 @@ checkout_files () {
lfmixcrlf=$1 ; shift
lfmixcr=$1 ; shift
crlfnul=$1 ; shift
- create_gitattributes "$attr" "$ident" &&
+ create_gitattributes "$attr" $ident $aeol &&
git config core.autocrlf $crlf &&
pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
@@ -245,7 +251,7 @@ checkout_files () {
fi
done
- test_expect_success "ls-files --eol attr=$attr $ident $aeol core.autocrlf=$crlf core.eol=$ceol" '
+ test_expect_success "ls-files --eol attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol" '
test_when_finished "rm expect actual" &&
sort <<-EOF >expect &&
i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
@@ -260,19 +266,19 @@ checkout_files () {
sort >actual &&
test_cmp expect actual
'
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
compare_ws_file $pfx $lfname crlf_false_attr__LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
compare_ws_file $pfx $crlfname crlf_false_attr__CRLF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
compare_ws_file $pfx $lfmixcrlf crlf_false_attr__CRLF_mix_LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
compare_ws_file $pfx $lfmixcr crlf_false_attr__LF_mix_CR.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
compare_ws_file $pfx $crlfnul crlf_false_attr__LF_nul.txt
"
}
@@ -386,31 +392,31 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
-commit_chk_wrnNNO false "" "" "" "" "" ""
-commit_chk_wrnNNO true "" "LF_CRLF" "" "" "" ""
-commit_chk_wrnNNO input "" "" "" "" "" ""
-
+# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+commit_chk_wrnNNO "" "" false "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO false "auto" "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO true "auto" "LF_CRLF" "" "LF_CRLF" "" ""
-commit_chk_wrnNNO input "auto" "" "CRLF_LF" "CRLF_LF" "" ""
+commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-commit_chk_wrnNNO false "text" "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO true "text" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "text" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-
-commit_chk_wrnNNO false "-text" "" "" "" "" ""
-commit_chk_wrnNNO true "-text" "" "" "" "" ""
-commit_chk_wrnNNO input "-text" "" "" "" "" ""
-
-commit_chk_wrnNNO false "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO true "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO input "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
+for crlf in true false input
+do
+ commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+done
-commit_chk_wrnNNO false "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO true "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
test_expect_success 'create files cleanup' '
rm -f *.txt &&
@@ -441,24 +447,20 @@ test_expect_success 'commit -text' '
check_files_in_repo input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
'
-# attr LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
-check_in_repo_NNO false "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "auto" LF LF LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO true "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO input "text" LF LF LF LF_mix_CR LF_nul
-
-check_in_repo_NNO false "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-
+for crlf in true false input
+do
+ # attr aeol LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
+ check_in_repo_NNO "" "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+done
################################################################################
# Check how files in the repo are changed when they are checked out
# How to read the table below:
@@ -490,89 +492,47 @@ LFNUL=LF_nul
fi
export CRLF_MIX_LF_CR MIX NL
-checkout_files "" "" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true "" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true crlf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true lf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true native CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true "" CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true lf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true native CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-
-for id in "" ident;
+# Same handling with and without ident
+for id in ""
do
- checkout_files "crlf" "$id" "" false "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "lf" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "-text" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ for ceol in lf crlf native
+ do
+ for crlf in true false input
+ do
+ # -text overrides core.autocrlf and core.eol
+ # text and eol=crlf or eol=lf override core.autocrlf and core.eol
+ checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # currently the same as text, eol=XXX
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+
+ # core.autocrlf false, different core.eol
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # core.autocrlf true
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf = true overrides core.eol
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # text: core.autocrlf = input overrides core.eol
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text=auto + eol=XXX
+ done
+ # text: core.autocrlf=false uses core.eol
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ # auto: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 04/10] convert.c: ident + core.autocrlf didn't work
2016-03-07 22:34 ` Junio C Hamano
` (41 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 03/10] t0027: test cases for combined attributes tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-25 16:56 ` [PATCH v7 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
` (22 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When the ident attributes is set, get_stream_filter() did not obey
core.autocrlf=true, and the file was checked out with LF.
Change the rule when a streaming filter can be used:
- if an external filter is specified, don't use a stream filter.
- if the worktree eol is CRLF and "auto" is active, don't use a stream filter.
- Otherwise the stream filter can be used.
Add test cases in t0027.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 19 +++++++------------
t/t0027-auto-crlf.sh | 2 +-
2 files changed, 8 insertions(+), 13 deletions(-)
diff --git a/convert.c b/convert.c
index f524b8d..b1614bf 100644
--- a/convert.c
+++ b/convert.c
@@ -1380,27 +1380,22 @@ static struct stream_filter *ident_filter(const unsigned char *sha1)
struct stream_filter *get_stream_filter(const char *path, const unsigned char *sha1)
{
struct conv_attrs ca;
- enum crlf_action crlf_action;
struct stream_filter *filter = NULL;
convert_attrs(&ca, path);
-
if (ca.drv && (ca.drv->smudge || ca.drv->clean))
- return filter;
+ return NULL;
+
+ if (ca.crlf_action == CRLF_AUTO || ca.crlf_action == CRLF_AUTO_CRLF)
+ return NULL;
if (ca.ident)
filter = ident_filter(sha1);
- crlf_action = ca.crlf_action;
-
- if ((crlf_action == CRLF_BINARY) ||
- crlf_action == CRLF_AUTO_INPUT ||
- (crlf_action == CRLF_TEXT_INPUT))
- filter = cascade_filter(filter, &null_filter_singleton);
-
- else if (output_eol(crlf_action) == EOL_CRLF &&
- !(crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_CRLF))
+ if (output_eol(ca.crlf_action) == EOL_CRLF)
filter = cascade_filter(filter, lf_to_crlf_filter());
+ else
+ filter = cascade_filter(filter, &null_filter_singleton);
return filter;
}
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index fd5e326..9372589 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -493,7 +493,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 05/10] read-cache: factor out get_sha1_from_index() helper
2016-03-07 22:34 ` Junio C Hamano
` (42 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 04/10] convert.c: ident + core.autocrlf didn't work tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-25 16:56 ` [PATCH v7 06/10] convert.c: stream and early out tboegi
` (21 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Factor out the retrieval of the sha1 for a given path in
read_blob_data_from_index() into the function get_sha1_from_index().
This will be used in the next commit, when convert.c can do the
analyze for "text=auto" without slurping the whole blob into memory
at once.
Add a wrapper definition get_sha1_from_cache().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
cache.h | 3 +++
read-cache.c | 29 ++++++++++++++++++-----------
2 files changed, 21 insertions(+), 11 deletions(-)
diff --git a/cache.h b/cache.h
index b829410..bd1210a 100644
--- a/cache.h
+++ b/cache.h
@@ -379,6 +379,7 @@ extern void free_name_hash(struct index_state *istate);
#define unmerge_cache_entry_at(at) unmerge_index_entry_at(&the_index, at)
#define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)
#define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))
+#define get_sha1_from_cache(path) get_sha1_from_index (&the_index, (path))
#endif
enum object_type {
@@ -1008,6 +1009,8 @@ static inline void *read_sha1_file(const unsigned char *sha1, enum object_type *
return read_sha1_file_extended(sha1, type, size, LOOKUP_REPLACE_OBJECT);
}
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path);
+
/*
* This internal function is only declared here for the benefit of
* lookup_replace_object(). Please do not call it directly.
diff --git a/read-cache.c b/read-cache.c
index d9fb78b..a3ef967 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -2263,13 +2263,27 @@ int index_name_is_other(const struct index_state *istate, const char *name,
void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
{
- int pos, len;
+ const unsigned char *sha1;
unsigned long sz;
enum object_type type;
void *data;
- len = strlen(path);
- pos = index_name_pos(istate, path, len);
+ sha1 = get_sha1_from_index(istate, path);
+ if (!sha1)
+ return NULL;
+ data = read_sha1_file(sha1, &type, &sz);
+ if (!data || type != OBJ_BLOB) {
+ free(data);
+ return NULL;
+ }
+ if (size)
+ *size = sz;
+ return data;
+}
+
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path)
+{
+ int pos = index_name_pos(istate, path, strlen(path));
if (pos < 0) {
/*
* We might be in the middle of a merge, in which
@@ -2285,14 +2299,7 @@ void *read_blob_data_from_index(struct index_state *istate, const char *path, un
}
if (pos < 0)
return NULL;
- data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
- if (!data || type != OBJ_BLOB) {
- free(data);
- return NULL;
- }
- if (size)
- *size = sz;
- return data;
+ return (istate->cache[pos]->sha1);
}
void stat_validity_clear(struct stat_validity *sv)
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 06/10] convert.c: stream and early out
2016-03-07 22:34 ` Junio C Hamano
` (43 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-25 16:56 ` [PATCH v7 07/10] convert: unify the "auto" handling of CRLF tboegi
` (20 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When statistics are done for the autocrlf handling, the search in
the content can be stopped, if e.g
- a search for binary is done, and a NUL character is found
- a search for CRLF is done, and the first CRLF is found.
Similar when statistics for binary vs non-binary are gathered:
Whenever a lone CR or NUL is found, the search can be aborted.
When checking out files in "auto" mode, any file that has a "lone CR"
or a CRLF will not be converted, so the search can be aborted early.
Add the new bit, CONVERT_STAT_BITS_ANY_CR,
which is set for either lone CR or CRLF.
Many binary files have a NUL very early (within the first few bytes,
latest within the first 1..2K).
It is often not necessary to load the whole content of a file or blob
into memory.
Use a streaming handling for blobs and files in the worktree.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 159 ++++++++++++++++++++++++++++++++++++++++----------------------
1 file changed, 103 insertions(+), 56 deletions(-)
diff --git a/convert.c b/convert.c
index b1614bf..24ab095 100644
--- a/convert.c
+++ b/convert.c
@@ -3,6 +3,7 @@
#include "run-command.h"
#include "quote.h"
#include "sigchain.h"
+#include "streaming.h"
/*
* convert.c - convert a file when checking it out and checking it in.
@@ -13,10 +14,10 @@
* translation when the "text" attribute or "auto_crlf" option is set.
*/
-/* Stat bits: When BIN is set, the txt bits are unset */
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
+#define CONVERT_STAT_BITS_ANY_CR 0x8
enum crlf_action {
CRLF_UNDEFINED,
@@ -31,30 +32,36 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned nul, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonecr, lonelf, crlf;
/* These are just approximations! */
unsigned printable, nonprintable;
};
-static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
+static void do_gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
{
unsigned long i;
- memset(stats, 0, sizeof(*stats));
-
+ if (!buf || !size)
+ return;
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
+ stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
stats->crlf++;
i++;
- } else
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
+ } else {
stats->lonecr++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+ }
continue;
}
if (c == '\n') {
stats->lonelf++;
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_LF;
continue;
}
if (c == 127)
@@ -67,7 +74,7 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
stats->printable++;
break;
case 0:
- stats->nul++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
/* fall through */
default:
stats->nonprintable++;
@@ -75,6 +82,8 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
}
else
stats->printable++;
+ if (stats->stat_bits & earlyout)
+ break; /* We found what we have been searching for */
}
/* If file ends with EOF then don't count this EOF as non-printable. */
@@ -86,41 +95,62 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
* The same heuristics as diff.c::mmfile_is_binary()
* We treat files with bare CR as binary
*/
-static int convert_is_binary(unsigned long size, const struct text_stat *stats)
+static void convert_nonprintable(struct text_stat *stats)
{
- if (stats->lonecr)
- return 1;
- if (stats->nul)
- return 1;
if ((stats->printable >> 7) < stats->nonprintable)
- return 1;
- return 0;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+}
+
+static void gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
+{
+ memset(stats, 0, sizeof(*stats));
+ do_gather_stats(buf, size, stats, earlyout);
+ convert_nonprintable(stats);
}
-static unsigned int gather_convert_stats(const char *data, unsigned long size)
+
+static unsigned get_convert_stats_sha1(unsigned const char *sha1,
+ unsigned earlyout)
{
+ struct git_istream *st;
struct text_stat stats;
- int ret = 0;
- if (!data || !size)
- return 0;
- gather_stats(data, size, &stats);
- if (convert_is_binary(size, &stats))
- ret |= CONVERT_STAT_BITS_BIN;
- if (stats.crlf)
- ret |= CONVERT_STAT_BITS_TXT_CRLF;
- if (stats.lonelf)
- ret |= CONVERT_STAT_BITS_TXT_LF;
+ enum object_type type;
+ unsigned long sz;
- return ret;
+ if (!sha1)
+ return 0;
+ memset(&stats, 0, sizeof(stats));
+ st = open_istream(sha1, &type, &sz, NULL);
+ if (!st) {
+ return 0;
+ }
+ if (type != OBJ_BLOB)
+ goto close_and_exit_i;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read_istream(st, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+close_and_exit_i:
+ close_istream(st);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
}
-static const char *gather_convert_stats_ascii(const char *data, unsigned long size)
+static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned int convert_stats = gather_convert_stats(data, size);
-
+ unsigned mask = CONVERT_STAT_BITS_TXT_LF |
+ CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats) {
+ switch (convert_stats & mask) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -132,24 +162,45 @@ static const char *gather_convert_stats_ascii(const char *data, unsigned long si
}
}
+static unsigned get_convert_stats_wt(const char *path)
+{
+ struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ int fd;
+ memset(&stats, 0, sizeof(stats));
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ return 0;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read(fd, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+ close(fd);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
+}
+
const char *get_cached_convert_stats_ascii(const char *path)
{
- const char *ret;
- unsigned long sz;
- void *data = read_blob_data_from_cache(path, &sz);
- ret = gather_convert_stats_ascii(data, sz);
- free(data);
- return ret;
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
}
const char *get_wt_convert_stats_ascii(const char *path)
{
- const char *ret = "";
- struct strbuf sb = STRBUF_INIT;
- if (strbuf_read_file(&sb, path, 0) >= 0)
- ret = gather_convert_stats_ascii(sb.buf, sb.len);
- strbuf_release(&sb);
- return ret;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_wt(path);
+ return convert_stats_ascii(convert_stats);
}
static int text_eol_is_crlf(void)
@@ -219,16 +270,10 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
static int has_cr_in_index(const char *path)
{
- unsigned long sz;
- void *data;
- int has_cr;
-
- data = read_blob_data_from_cache(path, &sz);
- if (!data)
- return 0;
- has_cr = memchr(data, '\r', sz) != NULL;
- free(data);
- return has_cr;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_ANY_CR);
+ return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -249,10 +294,10 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
@@ -309,11 +354,13 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
+
if (!len || output_eol(crlf_action) != EOL_CRLF)
return 0;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, earlyout);
/* No "naked" LF? Nothing to convert, regardless. */
if (!stats.lonelf)
@@ -327,7 +374,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
}
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
}
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 07/10] convert: unify the "auto" handling of CRLF
2016-03-07 22:34 ` Junio C Hamano
` (44 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 06/10] convert.c: stream and early out tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-25 19:37 ` Junio C Hamano
2016-04-25 16:56 ` [PATCH v7 08/10] convert.c: more safer crlf handling with text attribute tboegi
` (19 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Before this change,
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
would have the same effect as
$ echo "* text" >.gitattributes
$ git config core.eol crlf
Since the 'eol' attribute had higher priority than 'text=auto', this may
corrupt binary files and is not what users expect to happen.
Make the 'eol' attribute to obey 'text=auto', and now
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
behaves the same as
$ echo "* text=auto" >.gitattributes
$ git config core.eol crlf
In other words,
$ echo "* text=auto eol=crlf" >.gitattributes
has the same effect as
$ git config core.autocrlf true
and
$ echo "* text=auto eol=lf" >.gitattributes
has the same effect as
$ git config core.autocrlf input
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 14 +++++++-------
Documentation/gitattributes.txt | 15 +++++++++------
convert.c | 42 +++++++++++++++++++++--------------------
convert.h | 3 ++-
t/t0025-crlf-auto.sh | 4 ++--
t/t0027-auto-crlf.sh | 32 +++++++++++++++----------------
t/t6038-merge-text-auto.sh | 23 ++++++++++++++--------
7 files changed, 73 insertions(+), 60 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 4a27ad4..9caf6ae 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -389,13 +389,13 @@ 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',
+ Setting this variable to "true" is the same as setting
+ the `text` attribute to "auto" on all files and core.eol to "crlf".
+ Set to true if you want to have `CRLF` line endings in your
+ working directory and the repository has LF line endings.
+ Text files are guaranteed not to be normalized: files that contain
+ `CRLF` in the repository will not be touched.
+ This variable can be set to 'input',
in which case no output conversion is performed.
core.symlinks::
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index e3b1de8..d7a124b 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -115,6 +115,7 @@ 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.eol` configuration variable for all text files.
+Note that `core.autocrlf` overrides `core.eol`
Set::
@@ -130,8 +131,9 @@ Unset::
Set to string value "auto"::
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.
+ end-of-line conversion. If Git decides that the content is
+ text, its line endings are converted to LF on checkin.
+ When the file has been commited with CRLF, no conversion is done.
Unspecified::
@@ -146,7 +148,7 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line normalization without any
+working directory. It enables end-of-line conversion without any
content checks, effectively setting the `text` attribute.
Set to string value "crlf"::
@@ -186,9 +188,10 @@ the working directory, and prevent .jpg files from being normalized
regardless of their content.
------------------------
+* text=auto
*.txt text
-*.vcproj eol=crlf
-*.sh eol=lf
+*.vcproj text eol=crlf
+*.sh text eol=lf
*.jpg -text
------------------------
@@ -198,7 +201,7 @@ 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.
+config variable "core.autocrlf" without using any attributes.
------------------------
[core]
diff --git a/convert.c b/convert.c
index 24ab095..3782172 100644
--- a/convert.c
+++ b/convert.c
@@ -227,7 +227,9 @@ static enum eol output_eol(enum crlf_action crlf_action)
return EOL_LF;
case CRLF_UNDEFINED:
case CRLF_AUTO_CRLF:
+ return EOL_CRLF;
case CRLF_AUTO_INPUT:
+ return EOL_LF;
case CRLF_TEXT:
case CRLF_AUTO:
/* fall through */
@@ -299,17 +301,15 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
-
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /*
- * 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 the file in the index has any CR in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ if (checksafe == SAFE_CRLF_RENORMALIZE)
+ checksafe = SAFE_CRLF_FALSE;
+ else if (has_cr_in_index(path))
+ return 0;
}
-
check_safe_crlf(path, crlf_action, &stats, checksafe);
/* Optimization: No CRLF? Nothing to convert, regardless. */
@@ -367,12 +367,10 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
- }
+ /* If we have any CR or CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (stats.lonecr || stats.crlf )
+ return 0;
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
@@ -833,7 +831,11 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
ca->drv = git_path_check_convert(ccheck + 2);
if (ca->crlf_action != CRLF_BINARY) {
enum eol eol_attr = git_path_check_eol(ccheck + 3);
- if (eol_attr == EOL_LF)
+ if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_LF)
+ ca->crlf_action = CRLF_AUTO_INPUT;
+ else if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_CRLF)
+ ca->crlf_action = CRLF_AUTO_CRLF;
+ else if (eol_attr == EOL_LF)
ca->crlf_action = CRLF_TEXT_INPUT;
else if (eol_attr == EOL_CRLF)
ca->crlf_action = CRLF_TEXT_CRLF;
@@ -892,9 +894,9 @@ const char *get_convert_attr_ascii(const char *path)
case CRLF_AUTO:
return "text=auto";
case CRLF_AUTO_CRLF:
- return "text=auto eol=crlf"; /* This is not supported yet */
+ return "text=auto eol=crlf";
case CRLF_AUTO_INPUT:
- return "text=auto eol=lf"; /* This is not supported yet */
+ return "text=auto eol=lf";
}
return "";
}
@@ -996,7 +998,7 @@ int renormalize_buffer(const char *path, const char *src, size_t len, struct str
src = dst->buf;
len = dst->len;
}
- return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_FALSE);
+ return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_RENORMALIZE);
}
/*****************************************************************
diff --git a/convert.h b/convert.h
index ccf436b..81b6cdf 100644
--- a/convert.h
+++ b/convert.h
@@ -7,7 +7,8 @@
enum safe_crlf {
SAFE_CRLF_FALSE = 0,
SAFE_CRLF_FAIL = 1,
- SAFE_CRLF_WARN = 2
+ SAFE_CRLF_WARN = 2,
+ SAFE_CRLF_RENORMALIZE = 4
};
extern enum safe_crlf safe_crlf;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index c164b46..d0bee08 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -114,7 +114,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
+test_expect_success 'text=auto, autocrlf=true does not normalize CRLF files' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
git config core.autocrlf true &&
@@ -126,7 +126,7 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
LFonlydiff=$(git diff LFonly) &&
CRLFonlydiff=$(git diff CRLFonly) &&
LFwithNULdiff=$(git diff LFwithNUL) &&
- test -z "$LFonlydiff" -a -n "$CRLFonlydiff" -a -z "$LFwithNULdiff"
+ test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 9372589..8367d0b 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -175,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text eol=lf" ;;
- auto,crlf) echo "text eol=crlf" ;;
+ auto,lf) echo "text=auto eol=lf" ;;
+ auto,crlf) echo "text=auto eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -397,10 +397,9 @@ commit_chk_wrnNNO "" "" false "" "" "" ""
commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
-commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-
+commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
@@ -408,8 +407,8 @@ do
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
done
@@ -454,9 +453,9 @@ do
check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
@@ -493,7 +492,8 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in "" ident
+#for id in "" ident
+for id in ""
do
for ceol in lf crlf native
do
@@ -509,7 +509,7 @@ do
checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
@@ -517,7 +517,7 @@ do
# core.autocrlf true
checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
@@ -531,8 +531,8 @@ do
checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 85c10b0..33b77ee 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -16,6 +16,13 @@ test_description='CRLF merge conflict across text=auto change
test_have_prereq SED_STRIPS_CR && SED_OPTIONS=-b
+compare_files () {
+ tr '\015\000' QN <"$1" >"$1".expect &&
+ tr '\015\000' QN <"$2" >"$2".actual &&
+ test_cmp "$1".expect "$2".actual &&
+ rm "$1".expect "$2".actual
+}
+
test_expect_success setup '
git config core.autocrlf false &&
@@ -30,7 +37,7 @@ test_expect_success setup '
git branch side &&
echo "* text=auto" >.gitattributes &&
- touch file &&
+ echo first line >file &&
git add .gitattributes file &&
test_tick &&
git commit -m "normalize file" &&
@@ -81,7 +88,7 @@ test_expect_success 'Merge after setting text=auto' '
rm -f .gitattributes &&
git reset --hard a &&
git merge b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Merge addition of text=auto' '
@@ -99,7 +106,7 @@ test_expect_success 'Merge addition of text=auto' '
rm -f .gitattributes &&
git reset --hard b &&
git merge a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
@@ -121,7 +128,7 @@ test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
git reset --hard a &&
test_must_fail git merge b &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
@@ -143,7 +150,7 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
git reset --hard b &&
test_must_fail git merge a &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_failure 'checkout -m after setting text=auto' '
@@ -158,7 +165,7 @@ test_expect_failure 'checkout -m after setting text=auto' '
git reset --hard initial &&
git checkout a -- . &&
git checkout -m b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'checkout -m addition of text=auto' '
@@ -173,7 +180,7 @@ test_expect_failure 'checkout -m addition of text=auto' '
git reset --hard initial &&
git checkout b -- . &&
git checkout -m a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'cherry-pick patch from after text=auto was added' '
@@ -187,7 +194,7 @@ test_expect_failure 'cherry-pick patch from after text=auto was added' '
git reset --hard b &&
test_must_fail git cherry-pick a >err 2>&1 &&
grep "[Nn]othing added" err &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Test delete/normalize conflict' '
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 08/10] convert.c: more safer crlf handling with text attribute
2016-03-07 22:34 ` Junio C Hamano
` (45 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 07/10] convert: unify the "auto" handling of CRLF tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-25 16:56 ` [PATCH v7 09/10] t6038; use crlf on all platforms tboegi
` (18 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
This patch extends the work done in commit c480539:
"Make it work also for un-normalized repositories". Make sure that CRLF
can be converted round trip, or don't convert them at all.
The old handling would treat a file as unchanged after checkout,
as long as it is not touched in the work tree and mtime matches the value
recorded in the index.
When the mtime is changed in the working tree, or the inode is changed,
the file is reported as modified.
The following sequence is now handled reproducable:
$ git init
$ printf "line1\r\n" >file.bat
$ git add file.bat
$ git commit -m "Add file with CRLF" file.bat
$ echo "*.bat text eol=crlf" >.gitattributes
$ git commit -m "bat files should have CRLF"
$ git status
# nothing to commit, working directory clean
$ git push <upstream>
$ printf "newline\r\n" >>file.bat
$ mv file.bat file.sav
$ git checkout file.bat
$ git status
#modified: file.bat
The new handling makes sure that after running "git reset --hard".
"git status" reports the working tree as clean regarding CRLF conversion.
It makes sure that the Git-internal eol conversion is
doing roundtrip. A user can still write an external smudge/clean filter
outside Git, which doesn't do a roundtrip and the working directory is
not clean.
The functionality of has_cr_in_index() is turned into has_crlf_in_index(),
and the function is integrated into would_convert_crlf_at_commit().
Check for CRLF in the index instead of CR, the bit CONVERT_STAT_BITS_ANY_CR
is no longer used and removed, as well as "lonecr" in struct text_stat.
Rewrite check_safe_crlf() in convert.c to simulate checkin-checkout,
to detect whether any line endings are converted.
Add a warning, similar to the CRLF-LF replacement, when a file is commited,
and after the next checkout the line endings are not what they should be.
Modify the lf_to_crlf_filter:
Files with LF are converted into CRLF, file with CRLF are not changed.
Files with mixed line endings are not converted, the filter fails, and Git
falls back to the non-streaming handling, see write_entry().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/gitattributes.txt | 19 ++--
convert.c | 235 +++++++++++++++++++++++++---------------
t/t0025-crlf-auto.sh | 8 +-
t/t0027-auto-crlf.sh | 92 ++++++++--------
4 files changed, 213 insertions(+), 141 deletions(-)
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index d7a124b..836461d 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -110,7 +110,7 @@ repository upon 'git add' and 'git commit'.
`text`
^^^^^^
-This attribute enables and controls end-of-line normalization. When a
+This attribute enables and controls end-of-line conversion. 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
@@ -120,8 +120,11 @@ Note that `core.autocrlf` overrides `core.eol`
Set::
Setting the `text` attribute on a path enables end-of-line
- normalization and marks the path as a text file. End-of-line
+ conversion and marks the path as a text file. End-of-line
conversion takes place without guessing the content type.
+ Files that have been commited with CRLF before the text attribute
+ is set and commited are not normalized. No end-of-line conversion
+ is done at checkout or checkin.
Unset::
@@ -131,9 +134,9 @@ Unset::
Set to string value "auto"::
When `text` is set to "auto", the path is marked for automatic
- end-of-line conversion. If Git decides that the content is
- text, its line endings are converted to LF on checkin.
- When the file has been commited with CRLF, no conversion is done.
+ end-of-line normalization. If Git decides that the content is
+ text, and the path has no CRLF in the index,
+ its line endings are converted to LF on checkin.
Unspecified::
@@ -148,8 +151,10 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line conversion without any
-content checks, effectively setting the `text` attribute.
+working directory. It sets the `text` attribute, unless `text=auto`
+is specified.
+When the file had been commited with CRLF in the index, no conversion
+is done at checkout or commit.
Set to string value "crlf"::
diff --git a/convert.c b/convert.c
index 3782172..3d36c45 100644
--- a/convert.c
+++ b/convert.c
@@ -17,7 +17,8 @@
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
-#define CONVERT_STAT_BITS_ANY_CR 0x8
+
+#define CONVERT_STAT_BITS_MIXED (CONVERT_STAT_BITS_TXT_LF | CONVERT_STAT_BITS_TXT_CRLF)
enum crlf_action {
CRLF_UNDEFINED,
@@ -32,7 +33,7 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned stat_bits, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonelf;
/* These are just approximations! */
unsigned printable, nonprintable;
@@ -48,13 +49,10 @@ static void do_gather_stats(const char *buf, unsigned long size,
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
- stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
- stats->crlf++;
i++;
stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
} else {
- stats->lonecr++;
stats->stat_bits |= CONVERT_STAT_BITS_BIN;
}
continue;
@@ -135,7 +133,7 @@ static unsigned get_convert_stats_sha1(unsigned const char *sha1,
if (!readlen)
break;
do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
- if (stats.stat_bits & earlyout)
+ if ((stats.stat_bits & earlyout) == earlyout)
break; /* We found what we have been searching for */
}
close_and_exit_i:
@@ -146,11 +144,9 @@ close_and_exit_i:
static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned mask = CONVERT_STAT_BITS_TXT_LF |
- CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats & mask) {
+ switch (convert_stats) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -162,7 +158,16 @@ static const char *convert_stats_ascii(unsigned convert_stats)
}
}
-static unsigned get_convert_stats_wt(const char *path)
+const char *get_cached_convert_stats_ascii(const char *path)
+{
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
+}
+
+const char *get_wt_convert_stats_ascii(const char *path)
{
struct text_stat stats;
unsigned earlyout = CONVERT_STAT_BITS_BIN;
@@ -170,7 +175,7 @@ static unsigned get_convert_stats_wt(const char *path)
memset(&stats, 0, sizeof(stats));
fd = open(path, O_RDONLY);
if (fd < 0)
- return 0;
+ return NULL;
for (;;) {
char buf[1024];
ssize_t readlen = read(fd, buf, sizeof(buf));
@@ -184,23 +189,7 @@ static unsigned get_convert_stats_wt(const char *path)
}
close(fd);
convert_nonprintable(&stats);
- return stats.stat_bits;
-}
-
-const char *get_cached_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- unsigned earlyout = CONVERT_STAT_BITS_BIN;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- earlyout);
- return convert_stats_ascii(convert_stats);
-}
-
-const char *get_wt_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_wt(path);
- return convert_stats_ascii(convert_stats);
+ return convert_stats_ascii(stats.stat_bits);
}
static int text_eol_is_crlf(void)
@@ -239,43 +228,95 @@ static enum eol output_eol(enum crlf_action crlf_action)
return core_eol;
}
+static int would_convert_lf_at_checkout(unsigned convert_stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ if (output_eol(crlf_action) != EOL_CRLF)
+ return 0;
+
+ /* No "naked" LF? Nothing to convert, regardless. */
+ if (!(convert_stats & CONVERT_STAT_BITS_TXT_LF))
+ return 0;
+
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ /* auto: binary files are not converted */
+ if (convert_stats & CONVERT_STAT_BITS_BIN)
+ return 0;
+ }
+ /* If we have any CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+
+}
+
+static int would_convert_crlf_at_commit(const char * path,
+ const struct text_stat *stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ unsigned stat_bits_index;
+ /* No CRLF? Nothing to convert, regardless. */
+ if (!(stats->stat_bits & CONVERT_STAT_BITS_TXT_CRLF))
+ return 0;
+ /*
+ * If the file in the index has any CRLF in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ stat_bits_index = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_TXT_CRLF);
+ if (stat_bits_index & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+}
+
static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
- struct text_stat *stats, enum safe_crlf checksafe)
+ enum safe_crlf checksafe,
+ unsigned convert_stats, unsigned new_convert_stats)
{
+ enum eol new_eol = output_eol(crlf_action);
+ const char *err_warn_msg = NULL;
if (!checksafe)
return;
-
- if (output_eol(crlf_action) == EOL_LF) {
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
/*
* 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.\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 (output_eol(crlf_action) == EOL_CRLF) {
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if (convert_stats & CONVERT_STAT_BITS_TXT_LF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_LF)) {
/*
* CRLFs would be added by checkout:
* check if we have "naked" LFs
*/
- if (stats->lonelf) {
- if (checksafe == SAFE_CRLF_WARN)
- 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);
- }
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if ((new_convert_stats & CONVERT_STAT_BITS_MIXED) == CONVERT_STAT_BITS_MIXED)
+ err_warn_msg = "mixed eol";
+ else if (new_eol == EOL_LF && new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ err_warn_msg = "CRLF";
+
+ if (err_warn_msg) {
+ if (checksafe == SAFE_CRLF_WARN)
+ warning("%s will be present after commit and checkout in %s.",
+ err_warn_msg, path);
+ else
+ die("%s will be present after commit and checkout in %s",
+ err_warn_msg, path);
}
-}
-
-static int has_cr_in_index(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- CONVERT_STAT_BITS_ANY_CR);
- return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -284,7 +325,7 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
{
struct text_stat stats;
char *dst;
-
+ int convert_crlf;
if (crlf_action == CRLF_BINARY ||
(src && !len))
return 0;
@@ -296,24 +337,42 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
-
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
- /*
- * If the file in the index has any CR in it, do not convert.
- * This is the new safer autocrlf handling.
- */
- if (checksafe == SAFE_CRLF_RENORMALIZE)
- checksafe = SAFE_CRLF_FALSE;
- else if (has_cr_in_index(path))
- return 0;
+ } else {
+ gather_stats(src, len, &stats, 0);
+ }
+ if (checksafe == SAFE_CRLF_RENORMALIZE) {
+ convert_crlf = 1;
+ checksafe = SAFE_CRLF_FALSE;
+ } else {
+ convert_crlf = would_convert_crlf_at_commit(path, &stats, len,
+ crlf_action);
}
- check_safe_crlf(path, crlf_action, &stats, checksafe);
- /* Optimization: No CRLF? Nothing to convert, regardless. */
- if (!stats.crlf)
+ if (checksafe) {
+ unsigned convert_stats = stats.stat_bits;
+ unsigned new_convert_stats = convert_stats;
+ /* Simulate commit */
+ if (convert_crlf &&
+ (new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_LF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_CRLF;
+ }
+ /* Simulate checkout */
+ if (would_convert_lf_at_checkout(new_convert_stats,
+ len, crlf_action)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_CRLF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_LF;
+ }
+ check_safe_crlf(path, crlf_action, checksafe,
+ convert_stats, new_convert_stats);
+ }
+ if (!convert_crlf)
return 0;
/*
@@ -327,7 +386,9 @@ 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 (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
/*
* If we guessed, we already know we rejected a file with
* lone CR, and we can strip a CR without looking at what
@@ -354,28 +415,15 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
- unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
-
-
- if (!len || output_eol(crlf_action) != EOL_CRLF)
+ unsigned earlyout = 0; /* Need to count lonelf */
+ if (!len)
return 0;
gather_stats(src, len, &stats, earlyout);
-
- /* No "naked" LF? Nothing to convert, regardless. */
- if (!stats.lonelf)
+ if (!would_convert_lf_at_checkout(stats.stat_bits,
+ len, crlf_action))
return 0;
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
-
- if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
- return 0;
- }
-
/* are we "faking" in place editing ? */
if (src == buf->buf)
to_free = strbuf_detach(buf, NULL);
@@ -1067,6 +1115,8 @@ int is_null_stream_filter(struct stream_filter *filter)
struct lf_to_crlf_filter {
struct stream_filter filter;
unsigned has_held:1;
+ unsigned expanded_loneLF:1;
+ unsigned had_CRLF:1;
char held;
};
@@ -1107,7 +1157,12 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
char ch = input[i];
if (ch == '\n') {
- output[o++] = '\r';
+ if (!lf_to_crlf->had_CRLF) {
+ output[o++] = '\r';
+ lf_to_crlf->expanded_loneLF = 1;
+ }
+ if (was_cr)
+ lf_to_crlf->had_CRLF = 1;
} else if (was_cr) {
/*
* Previous round saw CR and it is not followed
@@ -1136,6 +1191,14 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
was_cr = 0;
output[o++] = ch;
+ if (lf_to_crlf->expanded_loneLF &&
+ lf_to_crlf->had_CRLF) {
+ /*
+ * Mixed EOL, round trip not possible.
+ */
+ return 1;
+ }
+
}
*osize_p -= o;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index d0bee08..b5f93e2 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 "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'crlf=true causes a CRLF file to be normalized' '
+test_expect_success 'crlf=true causes a CRLF file not to be normalized' '
# Backwards compatibility check
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
@@ -49,10 +49,10 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
-test_expect_success 'text=true causes a CRLF file to be normalized' '
+test_expect_success 'text=true causes a CRLF file not to be normalized' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
echo "CRLFonly text" > .gitattributes &&
@@ -61,7 +61,7 @@ test_expect_success 'text=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 8367d0b..a16e513 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -71,10 +71,14 @@ check_warning () {
case "$1" in
LF_CRLF) echo "warning: LF will be replaced by CRLF" >"$2".expect ;;
CRLF_LF) echo "warning: CRLF will be replaced by LF" >"$2".expect ;;
+ CRLF) echo "warning: CRLF will be present after commit and checkout" >"$2".expect ;;
+ mixed) echo "warning: mixed eol will be present after commit and checkout" >"$2".expect ;;
'') >"$2".expect ;;
*) echo >&2 "Illegal 1": "$1" ; return false ;;
esac
- grep "will be replaced by" "$2" | sed -e "s/\(.*\) in [^ ]*$/\1/" | uniq >"$2".actual
+ egrep "will be replaced by|will be present after commit" "$2" |
+ sed -e "s/\(.*\) in [^ ]*$/\1/" |
+ uniq >"$2".actual
test_cmp "$2".expect "$2".actual
}
@@ -169,7 +173,7 @@ stats_ascii () {
# Take none (=empty), one or two args
# convert.c: eol=XX overrides text=auto
attr_ascii () {
- case $1,$2 in
+ case "$1","$2" in
-text,*) echo "-text" ;;
text,) echo "text" ;;
text,lf) echo "text eol=lf" ;;
@@ -349,10 +353,12 @@ then
WILC=LF_CRLF
WICL=
WAMIX=LF_CRLF
+ Pcrlf=
else
WILC=
WICL=CRLF_LF
WAMIX=CRLF_LF
+ Pcrlf=CRLF
fi
# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
@@ -392,31 +398,32 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
commit_chk_wrnNNO "" "" false "" "" "" "" ""
-commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "" "" input "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "" "" input "" CRLF mixed "" ""
+
+commit_chk_wrnNNO "auto" "" false "$WILC" "$Pcrlf" mixed "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF mixed "" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$Pcrlf" mixed "$WILC" "$Pcrlf"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" mixed LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF mixed "" CRLF
+
-commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
- commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
- commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" mixed LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF mixed "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" mixed "" ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" mixed LF_CRLF ""
done
-commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
-commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
-
test_expect_success 'create files cleanup' '
rm -f *.txt &&
git -c core.autocrlf=false reset --hard
@@ -456,9 +463,9 @@ do
check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
done
################################################################################
# Check how files in the repo are changed when they are checked out
@@ -479,12 +486,10 @@ done
if test_have_prereq NATIVE_CRLF
then
-MIX_CRLF_LF=CRLF
MIX_LF_CR=CRLF_mix_CR
NL=CRLF
LFNUL=CRLF_nul
else
-MIX_CRLF_LF=CRLF_mix_LF
MIX_LF_CR=LF_mix_CR
NL=LF
LFNUL=LF_nul
@@ -492,8 +497,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-#for id in "" ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
@@ -501,38 +505,38 @@ do
do
# -text overrides core.autocrlf and core.eol
# text and eol=crlf or eol=lf override core.autocrlf and core.eol
- checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text
- checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
- checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
- checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# core.autocrlf true
- checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
- checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text=auto + eol=XXX
done
# text: core.autocrlf=false uses core.eol
- checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false "" $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
+ checkout_files text "$id" "" false native $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 09/10] t6038; use crlf on all platforms
2016-03-07 22:34 ` Junio C Hamano
` (46 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 08/10] convert.c: more safer crlf handling with text attribute tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-25 16:56 ` [PATCH v7 10/10] ce_compare_data() did not respect conversion tboegi
` (17 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
t6038 uses different code, dependig if NATIVE_CRLF is set ot not. When
the native line endings are LF, merge.renormalize is not tested very well.
Change the test to always use CRLF by setting core.eol=crlf.
After doing so, the test fails:
rm '.gitattributes'
rm 'control_file'
rm 'file'
rm 'inert_file'
HEAD is now at 0d9ffb6 add line from b
error: addinfo_cache failed for path 'file'
file: unmerged (cbd69ec7cd12dd0989e853923867d94c8519aa52)
file: unmerged (ad55e240aeb42e0d9a0e18d6d8b02dd82ee3e527)
file: unmerged (99b633103c15c20cebebf821133ab526b0ff90b2)
fatal: git write-tree failed to write a tree
Merging:
0d9ffb6 add line from b
virtual a
found 1 common ancestor:
1c56df1 Initial
Auto-merging file
not ok 4 - Merge addition of text=auto
This will be addressed in the next commit.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t6038-merge-text-auto.sh | 37 +++++++++++--------------------------
1 file changed, 11 insertions(+), 26 deletions(-)
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 33b77ee..0108ead 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -25,6 +25,7 @@ compare_files () {
test_expect_success setup '
git config core.autocrlf false &&
+ git config core.eol crlf &&
echo first line | append_cr >file &&
echo first line >control_file &&
@@ -79,10 +80,8 @@ test_expect_success 'Merge after setting text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -97,10 +96,8 @@ test_expect_success 'Merge addition of text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -111,15 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected
- else
- echo first line >>expected &&
- echo same line >>expected &&
- echo ======= >>expected
- fi &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
+ echo ======= | append_cr >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -135,15 +126,9 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected
- else
- echo ======= >>expected &&
- echo first line >>expected &&
- echo same line >>expected
- fi &&
+ echo ======= | append_cr >>expected &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v7 10/10] ce_compare_data() did not respect conversion
2016-03-07 22:34 ` Junio C Hamano
` (47 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 09/10] t6038; use crlf on all platforms tboegi
@ 2016-04-25 16:56 ` tboegi
2016-04-29 15:01 ` [PATCH v8 01/10] t0027: make commit_chk_wrnNNO() reliable tboegi
` (16 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-25 16:56 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
We define the working tree file is clean if either:
* the result of running convert_to_git() on the working tree
contents matches what is in the index (because that would mean
doing another "git add" on the path is a no-op); OR
* the result of running convert_to_working_tree() on the content
in the index matches what is in the working tree (because that
would mean doing another "git checkout -f" on the path is a
no-op).
Add an extra check in ce_compare_data() in read_cache.c.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
read-cache.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++
t/t6038-merge-text-auto.sh | 14 +++++------
2 files changed, 68 insertions(+), 7 deletions(-)
diff --git a/read-cache.c b/read-cache.c
index a3ef967..48c4b31 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -156,17 +156,78 @@ void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
ce_mark_uptodate(ce);
}
+/*
+ * Compare the data in buf with the data in the file pointed by fd and
+ * return 0 if they are identical, and non-zero if they differ.
+ */
+static int compare_with_fd(const char *input, ssize_t len, int fd)
+{
+ for (;;) {
+ char buf[1024 * 16];
+ ssize_t chunk_len, read_len;
+
+ chunk_len = sizeof(buf) < len ? sizeof(buf) : len;
+ read_len = xread(fd, buf, chunk_len ? chunk_len : 1);
+
+ if (!read_len)
+ /* EOF on the working tree file */
+ return !len ? 0 : -1;
+
+ if (!len)
+ /* we expected there is nothing left */
+ return -1;
+
+ if (memcmp(buf, input, read_len))
+ return -1;
+ input += read_len;
+ len -= read_len;
+ }
+}
+
static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
{
int match = -1;
int fd = open(ce->name, O_RDONLY);
+ /*
+ * Would another "git add" on the path change what is in the
+ * index for the path?
+ */
if (fd >= 0) {
unsigned char sha1[20];
if (!index_fd(sha1, fd, st, OBJ_BLOB, ce->name, 0))
match = hashcmp(sha1, ce->sha1);
/* index_fd() closed the file descriptor already */
}
+ if (!match)
+ return match;
+
+ /*
+ * Would another "git checkout -f" out of the index change
+ * what is in the working tree file?
+ */
+ fd = open(ce->name, O_RDONLY);
+ if (fd >= 0) {
+ enum object_type type;
+ unsigned long size_long;
+ void *data = read_sha1_file(ce->sha1, &type, &size_long);
+
+ if (type == OBJ_BLOB) {
+ struct strbuf worktree = STRBUF_INIT;
+ if (convert_to_working_tree(ce->name, data,
+ size_long,
+ &worktree)) {
+ size_t size;
+ free(data);
+ data = strbuf_detach(&worktree, &size);
+ size_long = size;
+ }
+ if (!compare_with_fd(data, size_long, fd))
+ match = 0;
+ }
+ free(data);
+ close(fd);
+ }
return match;
}
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 0108ead..565daf3 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -108,9 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
+ echo ======= >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -121,14 +121,13 @@ test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
fuzz_conflict file >file.fuzzy &&
compare_files expected file.fuzzy
'
-
test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
+ echo ======= >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
@@ -138,6 +137,7 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
compare_files expected file.fuzzy
'
+
test_expect_failure 'checkout -m after setting text=auto' '
cat <<-\EOF >expected &&
first line
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH v7 01/10] t0027: Make commit_chk_wrnNNO() reliable
2016-04-25 16:56 ` [PATCH v7 01/10] t0027: Make commit_chk_wrnNNO() reliable tboegi
@ 2016-04-25 19:15 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-04-25 19:15 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> When the content of a commited file is unchanged and the attributes are changed,
> Git may not detect that the next commit must treat the file as changed.
> This happens when lstat() doesn't detect a change, since neither inode,
> mtime nor size are changed.
>
> Add a singe "Z" character to change the file size (and content).
singLe (no need to reroll for this nit; locally fixed already).
> When the files are compared later in checkout_files(), the "Z" is removed
> before the comparison.
>
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
> ---
> Change since v6b:
> - Remove 2 sparse warnings, thanks Ramsay
>
> diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
> index f33962b..9fe539b 100755
> --- a/t/t0027-auto-crlf.sh
> +++ b/t/t0027-auto-crlf.sh
> @@ -12,7 +12,7 @@ fi
>
> compare_files () {
> tr '\015\000' QN <"$1" >"$1".expect &&
> - tr '\015\000' QN <"$2" >"$2".actual &&
> + tr '\015\000' QN <"$2" | tr -d 'Z' >"$2".actual &&
> test_cmp "$1".expect "$2".actual &&
> rm "$1".expect "$2".actual
> }
> @@ -114,6 +114,7 @@ commit_chk_wrnNNO () {
> do
> fname=${pfx}_$f.txt &&
> cp $f $fname &&
> + printf Z >>"$fname" &&
> git -c core.autocrlf=$crlf add $fname 2>/dev/null &&
> git -c core.autocrlf=$crlf commit -m "commit_$fname" $fname >"${pfx}_$f.err" 2>&1
> done
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v7 07/10] convert: unify the "auto" handling of CRLF
2016-04-25 16:56 ` [PATCH v7 07/10] convert: unify the "auto" handling of CRLF tboegi
@ 2016-04-25 19:37 ` Junio C Hamano
2016-04-26 16:33 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-04-25 19:37 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> Before this change,
> $ echo "* text=auto" >.gitattributes
> $ echo "* eol=crlf" >>.gitattributes
>
> would have the same effect as
> $ echo "* text" >.gitattributes
> $ git config core.eol crlf
>
> Since the 'eol' attribute had higher priority than 'text=auto', this may
> corrupt binary files and is not what users expect to happen.
Is the last "Since ..." continuation of the above two, i.e. "with
the current code, the first one (unfortunately) means the same as
the second one, BECAUSE ..."? If so, s/Since/since/ (I needed to
read it twice to guess that is probably what you meant).
The above is a very good justification of the entire series,
illustrating why this is worth doing.
> Make the 'eol' attribute to obey 'text=auto', and now
s/to obey/obey/ (make X do Y, not make X to do Y); I'd probably
further do 's/obey/honor/' or even 's/obey/work better with/'
> $ echo "* text=auto" >.gitattributes
> $ echo "* eol=crlf" >>.gitattributes
> behaves the same as
> $ echo "* text=auto" >.gitattributes
> $ git config core.eol crlf
>
> In other words,
> $ echo "* text=auto eol=crlf" >.gitattributes
> has the same effect as
> $ git config core.autocrlf true
> and
> $ echo "* text=auto eol=lf" >.gitattributes
> has the same effect as
> $ git config core.autocrlf input
It is kind of disappointing that the none of the above block of
configuration examples does not quite say what the reader really
wants to know directly. I am guessing that the point is
now text=auto does autodetection even when eol=crlf is
specified, and files that are declared to be non-text will not
get clobbered with eol=crlf conversion
right? If that is the case, replacing everything below "In other
words" with these three lines would make the text much easier to
grok, I would think.
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
> ---
> Documentation/config.txt | 14 +++++++-------
> Documentation/gitattributes.txt | 15 +++++++++------
> convert.c | 42 +++++++++++++++++++++--------------------
> convert.h | 3 ++-
> t/t0025-crlf-auto.sh | 4 ++--
> t/t0027-auto-crlf.sh | 32 +++++++++++++++----------------
> t/t6038-merge-text-auto.sh | 23 ++++++++++++++--------
> 7 files changed, 73 insertions(+), 60 deletions(-)
>
> diff --git a/Documentation/config.txt b/Documentation/config.txt
> index 4a27ad4..9caf6ae 100644
> --- a/Documentation/config.txt
> +++ b/Documentation/config.txt
> @@ -389,13 +389,13 @@ 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',
> + Setting this variable to "true" is the same as setting
> + the `text` attribute to "auto" on all files and core.eol to "crlf".
> + Set to true if you want to have `CRLF` line endings in your
> + working directory and the repository has LF line endings.
> + Text files are guaranteed not to be normalized: files that contain
> + `CRLF` in the repository will not be touched.
This is not a new problem but the last sentence and a half look
bad. Telling readers "X is not guaranteed to happen" is not all
that useful--telling them what happens is. Also the use of colon
there is probably ungrammatical.
Set to true if you want to have CRLF line endings in your
working directory and LF line endings in the repository.
Text files that contain CRLF in the repository will not get
their end-of-line converted.
perhaps?
> diff --git a/convert.h b/convert.h
> index ccf436b..81b6cdf 100644
> --- a/convert.h
> +++ b/convert.h
> @@ -7,7 +7,8 @@
> enum safe_crlf {
> SAFE_CRLF_FALSE = 0,
> SAFE_CRLF_FAIL = 1,
> - SAFE_CRLF_WARN = 2
> + SAFE_CRLF_WARN = 2,
> + SAFE_CRLF_RENORMALIZE = 4
Are these bits in a word? If not where did 3 go?
> diff --git a/convert.c b/convert.c
> index 24ab095..3782172 100644
> --- a/convert.c
> +++ b/convert.c
> @@ -227,7 +227,9 @@ static enum eol output_eol(enum crlf_action crlf_action)
> return EOL_LF;
> case CRLF_UNDEFINED:
> case CRLF_AUTO_CRLF:
> + return EOL_CRLF;
Hmph, do we want UNDEFINED case to return EOL_CRLF here?
> case CRLF_AUTO_INPUT:
> + return EOL_LF;
> case CRLF_TEXT:
> case CRLF_AUTO:
> /* fall through */
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v7 07/10] convert: unify the "auto" handling of CRLF
2016-04-25 19:37 ` Junio C Hamano
@ 2016-04-26 16:33 ` Torsten Bögershausen
2016-04-26 17:42 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Torsten Bögershausen @ 2016-04-26 16:33 UTC (permalink / raw)
To: Junio C Hamano, tboegi; +Cc: git
On 25.04.16 21:37, Junio C Hamano wrote:
> tboegi@web.de writes:
Thanks for review.
Some comments are inline, and a suggestion to a new commit message at the end.
[]
>> diff --git a/Documentation/config.txt b/Documentation/config.txt
>> index 4a27ad4..9caf6ae 100644
>> --- a/Documentation/config.txt
>> +++ b/Documentation/config.txt
>> @@ -389,13 +389,13 @@ 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',
>> + Setting this variable to "true" is the same as setting
>> + the `text` attribute to "auto" on all files and core.eol to "crlf".
>> + Set to true if you want to have `CRLF` line endings in your
>> + working directory and the repository has LF line endings.
>> + Text files are guaranteed not to be normalized: files that contain
>> + `CRLF` in the repository will not be touched.
>
> This is not a new problem but the last sentence and a half look
> bad. Telling readers "X is not guaranteed to happen" is not all
> that useful--telling them what happens is. Also the use of colon
> there is probably ungrammatical.
>
> Set to true if you want to have CRLF line endings in your
> working directory and LF line endings in the repository.
> Text files that contain CRLF in the repository will not get
> their end-of-line converted.
>
> perhaps?
OK, but may be
s/end-of-line/line endings/
----------
Set to true if you want to have CRLF line endings in your
working directory and LF line endings in the repository.
Text files that contain CRLF in the repository will not get
their line endings converted.
>
>> diff --git a/convert.h b/convert.h
>> index ccf436b..81b6cdf 100644
>> --- a/convert.h
>> +++ b/convert.h
>> @@ -7,7 +7,8 @@
>> enum safe_crlf {
>> SAFE_CRLF_FALSE = 0,
>> SAFE_CRLF_FAIL = 1,
>> - SAFE_CRLF_WARN = 2
>> + SAFE_CRLF_WARN = 2,
>> + SAFE_CRLF_RENORMALIZE = 4
>
> Are these bits in a word? If not where did 3 go?
We use an enum, sometimes mixed with an int, so my brain automatically
changed it into a bit field.
"3" is probably better.
>
>> diff --git a/convert.c b/convert.c
>> index 24ab095..3782172 100644
>> --- a/convert.c
>> +++ b/convert.c
>> @@ -227,7 +227,9 @@ static enum eol output_eol(enum crlf_action crlf_action)
>> return EOL_LF;
>> case CRLF_UNDEFINED:
>> case CRLF_AUTO_CRLF:
>> + return EOL_CRLF;
>
> Hmph, do we want UNDEFINED case to return EOL_CRLF here?
>
>> case CRLF_AUTO_INPUT:
>> + return EOL_LF;
One of the compilers claimed that UNDEFINED was not handled in switch-case.
A Warning may be better ?
>> case CRLF_TEXT:
>> case CRLF_AUTO:
>> /* fall through */
>
How about this as the commit message:
--------------------------------------
convert: unify the "auto" handling of CRLF
From: Torsten Bögershausen <tboegi@web.de>
Before this change,
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
would have the same effect as
$ echo "* text" >.gitattributes
$ git config core.eol crlf
The 'eol' attribute had higher priority than 'text=auto'. Binary
files may had been corrupted, and this is not what users expect to happen.
Make the 'eol' attribute to work together with 'text=auto'.
With this change
$ echo "* text=auto eol=crlf" >.gitattributes
has the same effect as
$ git config core.autocrlf true
and
$ echo "* text=auto eol=lf" >.gitattributes
has the same effect as
$ git config core.autocrlf input
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v7 07/10] convert: unify the "auto" handling of CRLF
2016-04-26 16:33 ` Torsten Bögershausen
@ 2016-04-26 17:42 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-04-26 17:42 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
>>> diff --git a/convert.c b/convert.c
>>> index 24ab095..3782172 100644
>>> --- a/convert.c
>>> +++ b/convert.c
>>> @@ -227,7 +227,9 @@ static enum eol output_eol(enum crlf_action crlf_action)
>>> return EOL_LF;
>>> case CRLF_UNDEFINED:
>>> case CRLF_AUTO_CRLF:
>>> + return EOL_CRLF;
>>
>> Hmph, do we want UNDEFINED case to return EOL_CRLF here?
>>
>>> case CRLF_AUTO_INPUT:
>>> + return EOL_LF;
> One of the compilers claimed that UNDEFINED was not handled in switch-case.
> A Warning may be better ?
>>> case CRLF_TEXT:
>>> case CRLF_AUTO:
>>> /* fall through */
The original made it fall-through; a very simple "a patch that makes
auto=crlf or auto=input do something different shouldn't have any
effect on the undefined case" was what triggered my reaction.
If returning EOL_CRLF does not make any sense for UNDEFINED case, it
shouldn't. If the codeflow should not reach without crlf_action
computed to something other than UNDEFINED, then you should have a
die("BUG") there.
Looking at a larger context, you already have a warning there:
static enum eol output_eol(enum crlf_action crlf_action)
{
switch (crlf_action) {
case CRLF_BINARY:
return EOL_UNSET;
...
case CRLF_AUTO:
/* fall through */
return text_eol_is_crlf() ? EOL_CRLF : EOL_LF;
}
warning("Illegal crlf_action %d\n", (int)crlf_action);
return core_eol;
}
which tells me that you shouldn't even have CRLF_UNDEFINED listed if
you have no intention to treat UNDEFINED as a valid input in this
codepath. Instead just doing
switch (crlf_action) {
case ...: /* handle all valid inputs appropriately */
return ...;
...
default: /* the above should cover all valid cases */
break;
}
warning(...);
return ...;
and not listing CRLF_UNDEFINED in any of the case arms would make
your intention more clear.
>>
> How about this as the commit message:
> --------------------------------------
> ...
> The 'eol' attribute had higher priority than 'text=auto'. Binary
> files may had been corrupted, and this is not what users expect to happen.
>
> Make the 'eol' attribute to work together with 'text=auto'.
The primary issue I had was that "work together" was a useful
explanation only to those who already understand what you are trying
to do with this patch.
Something like:
Having an "eol" attribute is taken as a declaration that the
path is text. This may be logical (on a binary blob, you
wouldn't be defining an "eol" attribute in the first place)
but is not very useful if you wanted to say "I do not know
if the path is text; inspect the contents to see if it is
text, and apply this 'eol' conversion only if it is".
"text=auto" attribute combined with an "eol" attribute ought
to have meant that, but it didn't. Make it so.
would be sufficient without any configuration example, I would think.
> With this change
>
> $ echo "* text=auto eol=crlf" >.gitattributes
> has the same effect as
> $ git config core.autocrlf true
>
> and
>
> $ echo "* text=auto eol=lf" >.gitattributes
> has the same effect as
> $ git config core.autocrlf input
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH v8 01/10] t0027: make commit_chk_wrnNNO() reliable
2016-03-07 22:34 ` Junio C Hamano
` (48 preceding siblings ...)
2016-04-25 16:56 ` [PATCH v7 10/10] ce_compare_data() did not respect conversion tboegi
@ 2016-04-29 15:01 ` tboegi
2016-04-29 15:01 ` [PATCH v8 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
` (15 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-29 15:01 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When the content of a commited file is unchanged and the attributes
are changed, Git may not detect that the next commit must treat the
file as changed. This happens when lstat() doesn't detect a change,
since neither inode, mtime nor size are changed.
Add a single "Z" character to change the file size and content.
When the files are compared later in checkout_files(), the "Z" is
removed before the comparison.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Changes against tb/convert-eol-autocrlf:
7/10 Implemented all comments, new commit message++
t/t0027-auto-crlf.sh | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index f33962b..9fe539b 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -12,7 +12,7 @@ fi
compare_files () {
tr '\015\000' QN <"$1" >"$1".expect &&
- tr '\015\000' QN <"$2" >"$2".actual &&
+ tr '\015\000' QN <"$2" | tr -d 'Z' >"$2".actual &&
test_cmp "$1".expect "$2".actual &&
rm "$1".expect "$2".actual
}
@@ -114,6 +114,7 @@ commit_chk_wrnNNO () {
do
fname=${pfx}_$f.txt &&
cp $f $fname &&
+ printf Z >>"$fname" &&
git -c core.autocrlf=$crlf add $fname 2>/dev/null &&
git -c core.autocrlf=$crlf commit -m "commit_$fname" $fname >"${pfx}_$f.err" 2>&1
done
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v8 02/10] convert: allow core.autocrlf=input and core.eol=crlf
2016-03-07 22:34 ` Junio C Hamano
` (49 preceding siblings ...)
2016-04-29 15:01 ` [PATCH v8 01/10] t0027: make commit_chk_wrnNNO() reliable tboegi
@ 2016-04-29 15:01 ` tboegi
2016-04-29 15:01 ` [PATCH v8 03/10] t0027: test cases for combined attributes tboegi
` (14 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-29 15:01 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Even though the configuration parser errors out when core.autocrlf
is set to 'input' when core.eol is set to 'crlf', there is no need
to do so, because the core.autocrlf setting trumps core.eol.
Allow all combinations of core.crlf and core.eol and document
that core.autocrlf overrides core.eol.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 6 +++---
config.c | 4 ----
2 files changed, 3 insertions(+), 7 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 2cd6bdd..4a27ad4 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -337,9 +337,9 @@ core.quotePath::
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
+ files that have the `text` property set when core.autocrlf is false.
+ 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.
diff --git a/config.c b/config.c
index 9ba40bc..a6adc8b 100644
--- a/config.c
+++ b/config.c
@@ -803,8 +803,6 @@ static int git_default_core_config(const char *var, const char *value)
if (!strcmp(var, "core.autocrlf")) {
if (value && !strcasecmp(value, "input")) {
- if (core_eol == EOL_CRLF)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
auto_crlf = AUTO_CRLF_INPUT;
return 0;
}
@@ -830,8 +828,6 @@ static int git_default_core_config(const char *var, const char *value)
core_eol = EOL_NATIVE;
else
core_eol = EOL_UNSET;
- if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
- return error("core.autocrlf=input conflicts with core.eol=crlf");
return 0;
}
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v8 03/10] t0027: test cases for combined attributes
2016-03-07 22:34 ` Junio C Hamano
` (50 preceding siblings ...)
2016-04-29 15:01 ` [PATCH v8 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
@ 2016-04-29 15:01 ` tboegi
2016-04-29 15:01 ` [PATCH v8 04/10] convert.c: ident + core.autocrlf didn't work tboegi
` (13 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-29 15:01 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Add more test cases for the not normalized files ("NNO"). The
"text" attribute is most important, use it as the first parameter.
"ident", if set, is the second paramater followed by the eol
attribute. The eol attribute overrides core.autocrlf, which
overrides core.eol.
indent is not yet used, this will be done in the next commit.
Use loops to test more combinations of attributes, like
"* text eol=crlf" or especially "*text=auto eol=crlf".
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t0027-auto-crlf.sh | 298 ++++++++++++++++++++++-----------------------------
1 file changed, 129 insertions(+), 169 deletions(-)
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 9fe539b..fd5e326 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -52,14 +52,17 @@ create_gitattributes () {
create_NNO_files () {
for crlf in false true input
do
- for attr in "" auto text -text lf crlf
+ for attr in "" auto text -text
do
- pfx=NNO_${crlf}_attr_${attr} &&
- cp CRLF_mix_LF ${pfx}_LF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
- cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
- cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ for aeol in "" lf crlf
+ do
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ cp CRLF_mix_LF ${pfx}_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
+ cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
+ cp CRLF_mix_LF ${pfx}_CRLF_nul.txt
+ done
done
done
}
@@ -100,16 +103,17 @@ commit_check_warn () {
}
commit_chk_wrnNNO () {
- crlf=$1
- attr=$2
- lfwarn=$3
- crlfwarn=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfwarn=$1 ; shift
+ crlfwarn=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
#Commit files on top of existing file
- create_gitattributes "$attr" &&
+ create_gitattributes "$attr" $aeol &&
for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
do
fname=${pfx}_$f.txt &&
@@ -122,19 +126,19 @@ commit_chk_wrnNNO () {
test_expect_success "commit NNO files crlf=$crlf attr=$attr LF" '
check_warning "$lfwarn" ${pfx}_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF" '
check_warning "$crlfwarn" ${pfx}_CRLF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_mix_LF" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_mix_LF" '
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr LF_mix_cr" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf LF_mix_cr" '
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
'
- test_expect_success "commit NNO files crlf=$crlf attr=$attr CRLF_nul" '
+ test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_nul" '
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
'
}
@@ -163,6 +167,7 @@ stats_ascii () {
# contruct the attr/ returned by git ls-files --eol
# Take none (=empty), one or two args
+# convert.c: eol=XX overrides text=auto
attr_ascii () {
case $1,$2 in
-text,*) echo "-text" ;;
@@ -170,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text=auto eol=lf" ;;
- auto,crlf) echo "text=auto eol=crlf" ;;
+ auto,lf) echo "text eol=lf" ;;
+ auto,crlf) echo "text eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -196,28 +201,29 @@ check_files_in_repo () {
}
check_in_repo_NNO () {
- crlf=$1
- attr=$2
- lfname=$3
- crlfname=$4
- lfmixcrlf=$5
- lfmixcr=$6
- crlfnul=$7
- pfx=NNO_${crlf}_attr_${attr}_
- test_expect_success "compare_files $lfname ${pfx}LF.txt" '
- compare_files $lfname ${pfx}LF.txt
+ attr=$1 ; shift
+ aeol=$1 ; shift
+ crlf=$1 ; shift
+ lfname=$1 ; shift
+ crlfname=$1 ; shift
+ lfmixcrlf=$1 ; shift
+ lfmixcr=$1 ; shift
+ crlfnul=$1 ; shift
+ pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
+ test_expect_success "compare_files $lfname ${pfx}_LF.txt" '
+ compare_files $lfname ${pfx}_LF.txt
'
- test_expect_success "compare_files $crlfname ${pfx}CRLF.txt" '
- compare_files $crlfname ${pfx}CRLF.txt
+ test_expect_success "compare_files $crlfname ${pfx}_CRLF.txt" '
+ compare_files $crlfname ${pfx}_CRLF.txt
'
- test_expect_success "compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt" '
- compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt
+ test_expect_success "compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt" '
+ compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt
'
- test_expect_success "compare_files $lfmixcr ${pfx}LF_mix_CR.txt" '
- compare_files $lfmixcr ${pfx}LF_mix_CR.txt
+ test_expect_success "compare_files $lfmixcr ${pfx}_LF_mix_CR.txt" '
+ compare_files $lfmixcr ${pfx}_LF_mix_CR.txt
'
- test_expect_success "compare_files $crlfnul ${pfx}CRLF_nul.txt" '
- compare_files $crlfnul ${pfx}CRLF_nul.txt
+ test_expect_success "compare_files $crlfnul ${pfx}_CRLF_nul.txt" '
+ compare_files $crlfnul ${pfx}_CRLF_nul.txt
'
}
@@ -232,7 +238,7 @@ checkout_files () {
lfmixcrlf=$1 ; shift
lfmixcr=$1 ; shift
crlfnul=$1 ; shift
- create_gitattributes "$attr" "$ident" &&
+ create_gitattributes "$attr" $ident $aeol &&
git config core.autocrlf $crlf &&
pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
@@ -245,7 +251,7 @@ checkout_files () {
fi
done
- test_expect_success "ls-files --eol attr=$attr $ident $aeol core.autocrlf=$crlf core.eol=$ceol" '
+ test_expect_success "ls-files --eol attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol" '
test_when_finished "rm expect actual" &&
sort <<-EOF >expect &&
i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
@@ -260,19 +266,19 @@ checkout_files () {
sort >actual &&
test_cmp expect actual
'
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
compare_ws_file $pfx $lfname crlf_false_attr__LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
compare_ws_file $pfx $crlfname crlf_false_attr__CRLF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
compare_ws_file $pfx $lfmixcrlf crlf_false_attr__CRLF_mix_LF.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
compare_ws_file $pfx $lfmixcr crlf_false_attr__LF_mix_CR.txt
"
- test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
+ test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
compare_ws_file $pfx $crlfnul crlf_false_attr__LF_nul.txt
"
}
@@ -386,31 +392,31 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
-commit_chk_wrnNNO false "" "" "" "" "" ""
-commit_chk_wrnNNO true "" "LF_CRLF" "" "" "" ""
-commit_chk_wrnNNO input "" "" "" "" "" ""
-
+# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+commit_chk_wrnNNO "" "" false "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO false "auto" "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO true "auto" "LF_CRLF" "" "LF_CRLF" "" ""
-commit_chk_wrnNNO input "auto" "" "CRLF_LF" "CRLF_LF" "" ""
+commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-commit_chk_wrnNNO false "text" "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO true "text" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "text" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-
-commit_chk_wrnNNO false "-text" "" "" "" "" ""
-commit_chk_wrnNNO true "-text" "" "" "" "" ""
-commit_chk_wrnNNO input "-text" "" "" "" "" ""
-
-commit_chk_wrnNNO false "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO true "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
-commit_chk_wrnNNO input "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
+for crlf in true false input
+do
+ commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+done
-commit_chk_wrnNNO false "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO true "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
-commit_chk_wrnNNO input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
test_expect_success 'create files cleanup' '
rm -f *.txt &&
@@ -441,24 +447,20 @@ test_expect_success 'commit -text' '
check_files_in_repo input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
'
-# attr LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
-check_in_repo_NNO false "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "auto" LF LF LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "auto" LF LF LF LF_mix_CR CRLF_nul
-
-check_in_repo_NNO false "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO true "text" LF LF LF LF_mix_CR LF_nul
-check_in_repo_NNO input "text" LF LF LF LF_mix_CR LF_nul
-
-check_in_repo_NNO false "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO true "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-check_in_repo_NNO input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
-
-
+for crlf in true false input
+do
+ # attr aeol LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
+ check_in_repo_NNO "" "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+done
################################################################################
# Check how files in the repo are changed when they are checked out
# How to read the table below:
@@ -490,89 +492,47 @@ LFNUL=LF_nul
fi
export CRLF_MIX_LF_CR MIX NL
-checkout_files "" "" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true "" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true crlf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true lf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" "" "" true native CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true "" CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true crlf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true lf CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" "" "" true native CRLF CRLF CRLF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-checkout_files "auto" ident "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
-
-for id in "" ident;
+# Same handling with and without ident
+for id in ""
do
- checkout_files "crlf" "$id" "" false "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" false native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" input lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "crlf" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "lf" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "lf" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files "text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "text" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "text" "$id" "" true native CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files "-text" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files "-text" "$id" "" true native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ for ceol in lf crlf native
+ do
+ for crlf in true false input
+ do
+ # -text overrides core.autocrlf and core.eol
+ # text and eol=crlf or eol=lf override core.autocrlf and core.eol
+ checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # currently the same as text, eol=XXX
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ done
+
+ # core.autocrlf false, different core.eol
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # core.autocrlf true
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf = true overrides core.eol
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ # text: core.autocrlf = input overrides core.eol
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text=auto + eol=XXX
+ done
+ # text: core.autocrlf=false uses core.eol
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ # text: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ # auto: core.autocrlf=false and core.eol unset(or native) uses native eol
+ checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v8 04/10] convert.c: ident + core.autocrlf didn't work
2016-03-07 22:34 ` Junio C Hamano
` (51 preceding siblings ...)
2016-04-29 15:01 ` [PATCH v8 03/10] t0027: test cases for combined attributes tboegi
@ 2016-04-29 15:01 ` tboegi
2016-04-29 15:02 ` [PATCH v8 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
` (12 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-29 15:01 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When the ident attributes is set, get_stream_filter() did not obey
core.autocrlf=true, and the file was checked out with LF.
Change the rule when a streaming filter can be used:
- if an external filter is specified, don't use a stream filter.
- if the worktree eol is CRLF and "auto" is active, don't use a stream filter.
- Otherwise the stream filter can be used.
Add test cases in t0027.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 19 +++++++------------
t/t0027-auto-crlf.sh | 2 +-
2 files changed, 8 insertions(+), 13 deletions(-)
diff --git a/convert.c b/convert.c
index f524b8d..b1614bf 100644
--- a/convert.c
+++ b/convert.c
@@ -1380,27 +1380,22 @@ static struct stream_filter *ident_filter(const unsigned char *sha1)
struct stream_filter *get_stream_filter(const char *path, const unsigned char *sha1)
{
struct conv_attrs ca;
- enum crlf_action crlf_action;
struct stream_filter *filter = NULL;
convert_attrs(&ca, path);
-
if (ca.drv && (ca.drv->smudge || ca.drv->clean))
- return filter;
+ return NULL;
+
+ if (ca.crlf_action == CRLF_AUTO || ca.crlf_action == CRLF_AUTO_CRLF)
+ return NULL;
if (ca.ident)
filter = ident_filter(sha1);
- crlf_action = ca.crlf_action;
-
- if ((crlf_action == CRLF_BINARY) ||
- crlf_action == CRLF_AUTO_INPUT ||
- (crlf_action == CRLF_TEXT_INPUT))
- filter = cascade_filter(filter, &null_filter_singleton);
-
- else if (output_eol(crlf_action) == EOL_CRLF &&
- !(crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_CRLF))
+ if (output_eol(ca.crlf_action) == EOL_CRLF)
filter = cascade_filter(filter, lf_to_crlf_filter());
+ else
+ filter = cascade_filter(filter, &null_filter_singleton);
return filter;
}
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index fd5e326..9372589 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -493,7 +493,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v8 05/10] read-cache: factor out get_sha1_from_index() helper
2016-03-07 22:34 ` Junio C Hamano
` (52 preceding siblings ...)
2016-04-29 15:01 ` [PATCH v8 04/10] convert.c: ident + core.autocrlf didn't work tboegi
@ 2016-04-29 15:02 ` tboegi
2016-04-29 15:02 ` [PATCH v8 06/10] convert.c: stream and early out tboegi
` (11 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-29 15:02 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Factor out the retrieval of the sha1 for a given path in
read_blob_data_from_index() into the function get_sha1_from_index().
This will be used in the next commit, when convert.c can do the
analyze for "text=auto" without slurping the whole blob into memory
at once.
Add a wrapper definition get_sha1_from_cache().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
cache.h | 3 +++
read-cache.c | 29 ++++++++++++++++++-----------
2 files changed, 21 insertions(+), 11 deletions(-)
diff --git a/cache.h b/cache.h
index b829410..bd1210a 100644
--- a/cache.h
+++ b/cache.h
@@ -379,6 +379,7 @@ extern void free_name_hash(struct index_state *istate);
#define unmerge_cache_entry_at(at) unmerge_index_entry_at(&the_index, at)
#define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)
#define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))
+#define get_sha1_from_cache(path) get_sha1_from_index (&the_index, (path))
#endif
enum object_type {
@@ -1008,6 +1009,8 @@ static inline void *read_sha1_file(const unsigned char *sha1, enum object_type *
return read_sha1_file_extended(sha1, type, size, LOOKUP_REPLACE_OBJECT);
}
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path);
+
/*
* This internal function is only declared here for the benefit of
* lookup_replace_object(). Please do not call it directly.
diff --git a/read-cache.c b/read-cache.c
index d9fb78b..a3ef967 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -2263,13 +2263,27 @@ int index_name_is_other(const struct index_state *istate, const char *name,
void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
{
- int pos, len;
+ const unsigned char *sha1;
unsigned long sz;
enum object_type type;
void *data;
- len = strlen(path);
- pos = index_name_pos(istate, path, len);
+ sha1 = get_sha1_from_index(istate, path);
+ if (!sha1)
+ return NULL;
+ data = read_sha1_file(sha1, &type, &sz);
+ if (!data || type != OBJ_BLOB) {
+ free(data);
+ return NULL;
+ }
+ if (size)
+ *size = sz;
+ return data;
+}
+
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path)
+{
+ int pos = index_name_pos(istate, path, strlen(path));
if (pos < 0) {
/*
* We might be in the middle of a merge, in which
@@ -2285,14 +2299,7 @@ void *read_blob_data_from_index(struct index_state *istate, const char *path, un
}
if (pos < 0)
return NULL;
- data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
- if (!data || type != OBJ_BLOB) {
- free(data);
- return NULL;
- }
- if (size)
- *size = sz;
- return data;
+ return (istate->cache[pos]->sha1);
}
void stat_validity_clear(struct stat_validity *sv)
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v8 06/10] convert.c: stream and early out
2016-03-07 22:34 ` Junio C Hamano
` (53 preceding siblings ...)
2016-04-29 15:02 ` [PATCH v8 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
@ 2016-04-29 15:02 ` tboegi
2016-04-29 15:02 ` [PATCH v8 07/10] convert: unify the "auto" handling of CRLF tboegi
` (10 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-29 15:02 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When statistics are done for the autocrlf handling, the search in
the content can be stopped, if e.g
- a search for binary is done, and a NUL character is found
- a search for CRLF is done, and the first CRLF is found.
Similar when statistics for binary vs non-binary are gathered:
Whenever a lone CR or NUL is found, the search can be aborted.
When checking out files in "auto" mode, any file that has a "lone CR"
or a CRLF will not be converted, so the search can be aborted early.
Add the new bit, CONVERT_STAT_BITS_ANY_CR,
which is set for either lone CR or CRLF.
Many binary files have a NUL very early (within the first few bytes,
latest within the first 1..2K).
It is often not necessary to load the whole content of a file or blob
into memory.
Use a streaming handling for blobs and files in the worktree.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 159 ++++++++++++++++++++++++++++++++++++++++----------------------
1 file changed, 103 insertions(+), 56 deletions(-)
diff --git a/convert.c b/convert.c
index b1614bf..24ab095 100644
--- a/convert.c
+++ b/convert.c
@@ -3,6 +3,7 @@
#include "run-command.h"
#include "quote.h"
#include "sigchain.h"
+#include "streaming.h"
/*
* convert.c - convert a file when checking it out and checking it in.
@@ -13,10 +14,10 @@
* translation when the "text" attribute or "auto_crlf" option is set.
*/
-/* Stat bits: When BIN is set, the txt bits are unset */
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
+#define CONVERT_STAT_BITS_ANY_CR 0x8
enum crlf_action {
CRLF_UNDEFINED,
@@ -31,30 +32,36 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned nul, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonecr, lonelf, crlf;
/* These are just approximations! */
unsigned printable, nonprintable;
};
-static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
+static void do_gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
{
unsigned long i;
- memset(stats, 0, sizeof(*stats));
-
+ if (!buf || !size)
+ return;
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
+ stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
stats->crlf++;
i++;
- } else
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
+ } else {
stats->lonecr++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+ }
continue;
}
if (c == '\n') {
stats->lonelf++;
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_LF;
continue;
}
if (c == 127)
@@ -67,7 +74,7 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
stats->printable++;
break;
case 0:
- stats->nul++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
/* fall through */
default:
stats->nonprintable++;
@@ -75,6 +82,8 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
}
else
stats->printable++;
+ if (stats->stat_bits & earlyout)
+ break; /* We found what we have been searching for */
}
/* If file ends with EOF then don't count this EOF as non-printable. */
@@ -86,41 +95,62 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
* The same heuristics as diff.c::mmfile_is_binary()
* We treat files with bare CR as binary
*/
-static int convert_is_binary(unsigned long size, const struct text_stat *stats)
+static void convert_nonprintable(struct text_stat *stats)
{
- if (stats->lonecr)
- return 1;
- if (stats->nul)
- return 1;
if ((stats->printable >> 7) < stats->nonprintable)
- return 1;
- return 0;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+}
+
+static void gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
+{
+ memset(stats, 0, sizeof(*stats));
+ do_gather_stats(buf, size, stats, earlyout);
+ convert_nonprintable(stats);
}
-static unsigned int gather_convert_stats(const char *data, unsigned long size)
+
+static unsigned get_convert_stats_sha1(unsigned const char *sha1,
+ unsigned earlyout)
{
+ struct git_istream *st;
struct text_stat stats;
- int ret = 0;
- if (!data || !size)
- return 0;
- gather_stats(data, size, &stats);
- if (convert_is_binary(size, &stats))
- ret |= CONVERT_STAT_BITS_BIN;
- if (stats.crlf)
- ret |= CONVERT_STAT_BITS_TXT_CRLF;
- if (stats.lonelf)
- ret |= CONVERT_STAT_BITS_TXT_LF;
+ enum object_type type;
+ unsigned long sz;
- return ret;
+ if (!sha1)
+ return 0;
+ memset(&stats, 0, sizeof(stats));
+ st = open_istream(sha1, &type, &sz, NULL);
+ if (!st) {
+ return 0;
+ }
+ if (type != OBJ_BLOB)
+ goto close_and_exit_i;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read_istream(st, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+close_and_exit_i:
+ close_istream(st);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
}
-static const char *gather_convert_stats_ascii(const char *data, unsigned long size)
+static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned int convert_stats = gather_convert_stats(data, size);
-
+ unsigned mask = CONVERT_STAT_BITS_TXT_LF |
+ CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats) {
+ switch (convert_stats & mask) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -132,24 +162,45 @@ static const char *gather_convert_stats_ascii(const char *data, unsigned long si
}
}
+static unsigned get_convert_stats_wt(const char *path)
+{
+ struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ int fd;
+ memset(&stats, 0, sizeof(stats));
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ return 0;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read(fd, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+ close(fd);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
+}
+
const char *get_cached_convert_stats_ascii(const char *path)
{
- const char *ret;
- unsigned long sz;
- void *data = read_blob_data_from_cache(path, &sz);
- ret = gather_convert_stats_ascii(data, sz);
- free(data);
- return ret;
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
}
const char *get_wt_convert_stats_ascii(const char *path)
{
- const char *ret = "";
- struct strbuf sb = STRBUF_INIT;
- if (strbuf_read_file(&sb, path, 0) >= 0)
- ret = gather_convert_stats_ascii(sb.buf, sb.len);
- strbuf_release(&sb);
- return ret;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_wt(path);
+ return convert_stats_ascii(convert_stats);
}
static int text_eol_is_crlf(void)
@@ -219,16 +270,10 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
static int has_cr_in_index(const char *path)
{
- unsigned long sz;
- void *data;
- int has_cr;
-
- data = read_blob_data_from_cache(path, &sz);
- if (!data)
- return 0;
- has_cr = memchr(data, '\r', sz) != NULL;
- free(data);
- return has_cr;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_ANY_CR);
+ return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -249,10 +294,10 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
@@ -309,11 +354,13 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
+
if (!len || output_eol(crlf_action) != EOL_CRLF)
return 0;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, earlyout);
/* No "naked" LF? Nothing to convert, regardless. */
if (!stats.lonelf)
@@ -327,7 +374,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
}
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
}
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v8 07/10] convert: unify the "auto" handling of CRLF
2016-03-07 22:34 ` Junio C Hamano
` (54 preceding siblings ...)
2016-04-29 15:02 ` [PATCH v8 06/10] convert.c: stream and early out tboegi
@ 2016-04-29 15:02 ` tboegi
2016-11-25 15:48 ` Torsten Bögershausen
2016-04-29 15:02 ` [PATCH v8 08/10] convert.c: more safer crlf handling with text attribute tboegi
` (9 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-04-29 15:02 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Before this change,
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
would have the same effect as
$ echo "* text" >.gitattributes
$ git config core.eol crlf
Having an "eol" attribute is taken as a declaration that the
path is text. This may be logical (on a binary blob, you
wouldn't be defining an "eol" attribute in the first place)
but is not very useful if you wanted to say "I do not know
if the path is text; inspect the contents to see if it is
text, and apply this 'eol' conversion only if it is".
"text=auto" attribute combined with an "eol" attribute ought
to have meant that, but it didn't. Make it so.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 14 ++++++------
Documentation/gitattributes.txt | 15 +++++++------
convert.c | 47 ++++++++++++++++++++++-------------------
convert.h | 3 ++-
t/t0025-crlf-auto.sh | 4 ++--
t/t0027-auto-crlf.sh | 32 ++++++++++++++--------------
t/t6038-merge-text-auto.sh | 23 +++++++++++++-------
7 files changed, 76 insertions(+), 62 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 4a27ad4..9caf6ae 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -389,13 +389,13 @@ 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',
+ Setting this variable to "true" is the same as setting
+ the `text` attribute to "auto" on all files and core.eol to "crlf".
+ Set to true if you want to have `CRLF` line endings in your
+ working directory and the repository has LF line endings.
+ Text files are guaranteed not to be normalized: files that contain
+ `CRLF` in the repository will not be touched.
+ This variable can be set to 'input',
in which case no output conversion is performed.
core.symlinks::
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index e3b1de8..d7a124b 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -115,6 +115,7 @@ 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.eol` configuration variable for all text files.
+Note that `core.autocrlf` overrides `core.eol`
Set::
@@ -130,8 +131,9 @@ Unset::
Set to string value "auto"::
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.
+ end-of-line conversion. If Git decides that the content is
+ text, its line endings are converted to LF on checkin.
+ When the file has been commited with CRLF, no conversion is done.
Unspecified::
@@ -146,7 +148,7 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line normalization without any
+working directory. It enables end-of-line conversion without any
content checks, effectively setting the `text` attribute.
Set to string value "crlf"::
@@ -186,9 +188,10 @@ the working directory, and prevent .jpg files from being normalized
regardless of their content.
------------------------
+* text=auto
*.txt text
-*.vcproj eol=crlf
-*.sh eol=lf
+*.vcproj text eol=crlf
+*.sh text eol=lf
*.jpg -text
------------------------
@@ -198,7 +201,7 @@ 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.
+config variable "core.autocrlf" without using any attributes.
------------------------
[core]
diff --git a/convert.c b/convert.c
index 24ab095..495c85c 100644
--- a/convert.c
+++ b/convert.c
@@ -225,16 +225,19 @@ static enum eol output_eol(enum crlf_action crlf_action)
return EOL_CRLF;
case CRLF_TEXT_INPUT:
return EOL_LF;
- case CRLF_UNDEFINED:
case CRLF_AUTO_CRLF:
+ return EOL_CRLF;
case CRLF_AUTO_INPUT:
+ return EOL_LF;
case CRLF_TEXT:
case CRLF_AUTO:
/* fall through */
return text_eol_is_crlf() ? EOL_CRLF : EOL_LF;
+ default: /* the above should cover all valid cases */
+ break;
}
warning("Illegal crlf_action %d\n", (int)crlf_action);
- return core_eol;
+ return EOL_UNSET;
}
static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
@@ -299,17 +302,15 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
-
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /*
- * 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 the file in the index has any CR in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ if (checksafe == SAFE_CRLF_RENORMALIZE)
+ checksafe = SAFE_CRLF_FALSE;
+ else if (has_cr_in_index(path))
+ return 0;
}
-
check_safe_crlf(path, crlf_action, &stats, checksafe);
/* Optimization: No CRLF? Nothing to convert, regardless. */
@@ -367,12 +368,10 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
- }
+ /* If we have any CR or CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (stats.lonecr || stats.crlf )
+ return 0;
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
@@ -833,7 +832,11 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
ca->drv = git_path_check_convert(ccheck + 2);
if (ca->crlf_action != CRLF_BINARY) {
enum eol eol_attr = git_path_check_eol(ccheck + 3);
- if (eol_attr == EOL_LF)
+ if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_LF)
+ ca->crlf_action = CRLF_AUTO_INPUT;
+ else if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_CRLF)
+ ca->crlf_action = CRLF_AUTO_CRLF;
+ else if (eol_attr == EOL_LF)
ca->crlf_action = CRLF_TEXT_INPUT;
else if (eol_attr == EOL_CRLF)
ca->crlf_action = CRLF_TEXT_CRLF;
@@ -892,9 +895,9 @@ const char *get_convert_attr_ascii(const char *path)
case CRLF_AUTO:
return "text=auto";
case CRLF_AUTO_CRLF:
- return "text=auto eol=crlf"; /* This is not supported yet */
+ return "text=auto eol=crlf";
case CRLF_AUTO_INPUT:
- return "text=auto eol=lf"; /* This is not supported yet */
+ return "text=auto eol=lf";
}
return "";
}
@@ -996,7 +999,7 @@ int renormalize_buffer(const char *path, const char *src, size_t len, struct str
src = dst->buf;
len = dst->len;
}
- return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_FALSE);
+ return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_RENORMALIZE);
}
/*****************************************************************
diff --git a/convert.h b/convert.h
index ccf436b..82871a1 100644
--- a/convert.h
+++ b/convert.h
@@ -7,7 +7,8 @@
enum safe_crlf {
SAFE_CRLF_FALSE = 0,
SAFE_CRLF_FAIL = 1,
- SAFE_CRLF_WARN = 2
+ SAFE_CRLF_WARN = 2,
+ SAFE_CRLF_RENORMALIZE = 3
};
extern enum safe_crlf safe_crlf;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index c164b46..d0bee08 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -114,7 +114,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
+test_expect_success 'text=auto, autocrlf=true does not normalize CRLF files' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
git config core.autocrlf true &&
@@ -126,7 +126,7 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
LFonlydiff=$(git diff LFonly) &&
CRLFonlydiff=$(git diff CRLFonly) &&
LFwithNULdiff=$(git diff LFwithNUL) &&
- test -z "$LFonlydiff" -a -n "$CRLFonlydiff" -a -z "$LFwithNULdiff"
+ test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 9372589..8367d0b 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -175,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text eol=lf" ;;
- auto,crlf) echo "text eol=crlf" ;;
+ auto,lf) echo "text=auto eol=lf" ;;
+ auto,crlf) echo "text=auto eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -397,10 +397,9 @@ commit_chk_wrnNNO "" "" false "" "" "" ""
commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
-commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-
+commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
@@ -408,8 +407,8 @@ do
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
done
@@ -454,9 +453,9 @@ do
check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
@@ -493,7 +492,8 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in "" ident
+#for id in "" ident
+for id in ""
do
for ceol in lf crlf native
do
@@ -509,7 +509,7 @@ do
checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
@@ -517,7 +517,7 @@ do
# core.autocrlf true
checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
@@ -531,8 +531,8 @@ do
checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 85c10b0..33b77ee 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -16,6 +16,13 @@ test_description='CRLF merge conflict across text=auto change
test_have_prereq SED_STRIPS_CR && SED_OPTIONS=-b
+compare_files () {
+ tr '\015\000' QN <"$1" >"$1".expect &&
+ tr '\015\000' QN <"$2" >"$2".actual &&
+ test_cmp "$1".expect "$2".actual &&
+ rm "$1".expect "$2".actual
+}
+
test_expect_success setup '
git config core.autocrlf false &&
@@ -30,7 +37,7 @@ test_expect_success setup '
git branch side &&
echo "* text=auto" >.gitattributes &&
- touch file &&
+ echo first line >file &&
git add .gitattributes file &&
test_tick &&
git commit -m "normalize file" &&
@@ -81,7 +88,7 @@ test_expect_success 'Merge after setting text=auto' '
rm -f .gitattributes &&
git reset --hard a &&
git merge b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Merge addition of text=auto' '
@@ -99,7 +106,7 @@ test_expect_success 'Merge addition of text=auto' '
rm -f .gitattributes &&
git reset --hard b &&
git merge a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
@@ -121,7 +128,7 @@ test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
git reset --hard a &&
test_must_fail git merge b &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
@@ -143,7 +150,7 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
git reset --hard b &&
test_must_fail git merge a &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_failure 'checkout -m after setting text=auto' '
@@ -158,7 +165,7 @@ test_expect_failure 'checkout -m after setting text=auto' '
git reset --hard initial &&
git checkout a -- . &&
git checkout -m b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'checkout -m addition of text=auto' '
@@ -173,7 +180,7 @@ test_expect_failure 'checkout -m addition of text=auto' '
git reset --hard initial &&
git checkout b -- . &&
git checkout -m a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'cherry-pick patch from after text=auto was added' '
@@ -187,7 +194,7 @@ test_expect_failure 'cherry-pick patch from after text=auto was added' '
git reset --hard b &&
test_must_fail git cherry-pick a >err 2>&1 &&
grep "[Nn]othing added" err &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Test delete/normalize conflict' '
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v8 08/10] convert.c: more safer crlf handling with text attribute
2016-03-07 22:34 ` Junio C Hamano
` (55 preceding siblings ...)
2016-04-29 15:02 ` [PATCH v8 07/10] convert: unify the "auto" handling of CRLF tboegi
@ 2016-04-29 15:02 ` tboegi
2016-04-29 15:02 ` [PATCH v8 09/10] t6038; use crlf on all platforms tboegi
` (8 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-29 15:02 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
This patch extends the work done in commit c480539:
"Make it work also for un-normalized repositories". Make sure that CRLF
can be converted round trip, or don't convert them at all.
The old handling would treat a file as unchanged after checkout,
as long as it is not touched in the work tree and mtime matches the value
recorded in the index.
When the mtime is changed in the working tree, or the inode is changed,
the file is reported as modified.
The following sequence is now handled reproducable:
$ git init
$ printf "line1\r\n" >file.bat
$ git add file.bat
$ git commit -m "Add file with CRLF" file.bat
$ echo "*.bat text eol=crlf" >.gitattributes
$ git commit -m "bat files should have CRLF"
$ git status
# nothing to commit, working directory clean
$ git push <upstream>
$ printf "newline\r\n" >>file.bat
$ mv file.bat file.sav
$ git checkout file.bat
$ git status
#modified: file.bat
The new handling makes sure that after running "git reset --hard".
"git status" reports the working tree as clean regarding CRLF conversion.
It makes sure that the Git-internal eol conversion is
doing roundtrip. A user can still write an external smudge/clean filter
outside Git, which doesn't do a roundtrip and the working directory is
not clean.
The functionality of has_cr_in_index() is turned into has_crlf_in_index(),
and the function is integrated into would_convert_crlf_at_commit().
Check for CRLF in the index instead of CR, the bit CONVERT_STAT_BITS_ANY_CR
is no longer used and removed, as well as "lonecr" in struct text_stat.
Rewrite check_safe_crlf() in convert.c to simulate checkin-checkout,
to detect whether any line endings are converted.
Add a warning, similar to the CRLF-LF replacement, when a file is commited,
and after the next checkout the line endings are not what they should be.
Modify the lf_to_crlf_filter:
Files with LF are converted into CRLF, file with CRLF are not changed.
Files with mixed line endings are not converted, the filter fails, and Git
falls back to the non-streaming handling, see write_entry().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/gitattributes.txt | 19 ++--
convert.c | 235 +++++++++++++++++++++++++---------------
t/t0025-crlf-auto.sh | 8 +-
t/t0027-auto-crlf.sh | 92 ++++++++--------
4 files changed, 213 insertions(+), 141 deletions(-)
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index d7a124b..836461d 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -110,7 +110,7 @@ repository upon 'git add' and 'git commit'.
`text`
^^^^^^
-This attribute enables and controls end-of-line normalization. When a
+This attribute enables and controls end-of-line conversion. 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
@@ -120,8 +120,11 @@ Note that `core.autocrlf` overrides `core.eol`
Set::
Setting the `text` attribute on a path enables end-of-line
- normalization and marks the path as a text file. End-of-line
+ conversion and marks the path as a text file. End-of-line
conversion takes place without guessing the content type.
+ Files that have been commited with CRLF before the text attribute
+ is set and commited are not normalized. No end-of-line conversion
+ is done at checkout or checkin.
Unset::
@@ -131,9 +134,9 @@ Unset::
Set to string value "auto"::
When `text` is set to "auto", the path is marked for automatic
- end-of-line conversion. If Git decides that the content is
- text, its line endings are converted to LF on checkin.
- When the file has been commited with CRLF, no conversion is done.
+ end-of-line normalization. If Git decides that the content is
+ text, and the path has no CRLF in the index,
+ its line endings are converted to LF on checkin.
Unspecified::
@@ -148,8 +151,10 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line conversion without any
-content checks, effectively setting the `text` attribute.
+working directory. It sets the `text` attribute, unless `text=auto`
+is specified.
+When the file had been commited with CRLF in the index, no conversion
+is done at checkout or commit.
Set to string value "crlf"::
diff --git a/convert.c b/convert.c
index 495c85c..790563d 100644
--- a/convert.c
+++ b/convert.c
@@ -17,7 +17,8 @@
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
-#define CONVERT_STAT_BITS_ANY_CR 0x8
+
+#define CONVERT_STAT_BITS_MIXED (CONVERT_STAT_BITS_TXT_LF | CONVERT_STAT_BITS_TXT_CRLF)
enum crlf_action {
CRLF_UNDEFINED,
@@ -32,7 +33,7 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned stat_bits, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonelf;
/* These are just approximations! */
unsigned printable, nonprintable;
@@ -48,13 +49,10 @@ static void do_gather_stats(const char *buf, unsigned long size,
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
- stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
- stats->crlf++;
i++;
stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
} else {
- stats->lonecr++;
stats->stat_bits |= CONVERT_STAT_BITS_BIN;
}
continue;
@@ -135,7 +133,7 @@ static unsigned get_convert_stats_sha1(unsigned const char *sha1,
if (!readlen)
break;
do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
- if (stats.stat_bits & earlyout)
+ if ((stats.stat_bits & earlyout) == earlyout)
break; /* We found what we have been searching for */
}
close_and_exit_i:
@@ -146,11 +144,9 @@ close_and_exit_i:
static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned mask = CONVERT_STAT_BITS_TXT_LF |
- CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats & mask) {
+ switch (convert_stats) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -162,7 +158,16 @@ static const char *convert_stats_ascii(unsigned convert_stats)
}
}
-static unsigned get_convert_stats_wt(const char *path)
+const char *get_cached_convert_stats_ascii(const char *path)
+{
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
+}
+
+const char *get_wt_convert_stats_ascii(const char *path)
{
struct text_stat stats;
unsigned earlyout = CONVERT_STAT_BITS_BIN;
@@ -170,7 +175,7 @@ static unsigned get_convert_stats_wt(const char *path)
memset(&stats, 0, sizeof(stats));
fd = open(path, O_RDONLY);
if (fd < 0)
- return 0;
+ return NULL;
for (;;) {
char buf[1024];
ssize_t readlen = read(fd, buf, sizeof(buf));
@@ -184,23 +189,7 @@ static unsigned get_convert_stats_wt(const char *path)
}
close(fd);
convert_nonprintable(&stats);
- return stats.stat_bits;
-}
-
-const char *get_cached_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- unsigned earlyout = CONVERT_STAT_BITS_BIN;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- earlyout);
- return convert_stats_ascii(convert_stats);
-}
-
-const char *get_wt_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_wt(path);
- return convert_stats_ascii(convert_stats);
+ return convert_stats_ascii(stats.stat_bits);
}
static int text_eol_is_crlf(void)
@@ -240,43 +229,95 @@ static enum eol output_eol(enum crlf_action crlf_action)
return EOL_UNSET;
}
+static int would_convert_lf_at_checkout(unsigned convert_stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ if (output_eol(crlf_action) != EOL_CRLF)
+ return 0;
+
+ /* No "naked" LF? Nothing to convert, regardless. */
+ if (!(convert_stats & CONVERT_STAT_BITS_TXT_LF))
+ return 0;
+
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ /* auto: binary files are not converted */
+ if (convert_stats & CONVERT_STAT_BITS_BIN)
+ return 0;
+ }
+ /* If we have any CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+
+}
+
+static int would_convert_crlf_at_commit(const char * path,
+ const struct text_stat *stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ unsigned stat_bits_index;
+ /* No CRLF? Nothing to convert, regardless. */
+ if (!(stats->stat_bits & CONVERT_STAT_BITS_TXT_CRLF))
+ return 0;
+ /*
+ * If the file in the index has any CRLF in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ stat_bits_index = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_TXT_CRLF);
+ if (stat_bits_index & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+}
+
static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
- struct text_stat *stats, enum safe_crlf checksafe)
+ enum safe_crlf checksafe,
+ unsigned convert_stats, unsigned new_convert_stats)
{
+ enum eol new_eol = output_eol(crlf_action);
+ const char *err_warn_msg = NULL;
if (!checksafe)
return;
-
- if (output_eol(crlf_action) == EOL_LF) {
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
/*
* 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.\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 (output_eol(crlf_action) == EOL_CRLF) {
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if (convert_stats & CONVERT_STAT_BITS_TXT_LF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_LF)) {
/*
* CRLFs would be added by checkout:
* check if we have "naked" LFs
*/
- if (stats->lonelf) {
- if (checksafe == SAFE_CRLF_WARN)
- 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);
- }
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if ((new_convert_stats & CONVERT_STAT_BITS_MIXED) == CONVERT_STAT_BITS_MIXED)
+ err_warn_msg = "mixed eol";
+ else if (new_eol == EOL_LF && new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ err_warn_msg = "CRLF";
+
+ if (err_warn_msg) {
+ if (checksafe == SAFE_CRLF_WARN)
+ warning("%s will be present after commit and checkout in %s.",
+ err_warn_msg, path);
+ else
+ die("%s will be present after commit and checkout in %s",
+ err_warn_msg, path);
}
-}
-
-static int has_cr_in_index(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- CONVERT_STAT_BITS_ANY_CR);
- return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -285,7 +326,7 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
{
struct text_stat stats;
char *dst;
-
+ int convert_crlf;
if (crlf_action == CRLF_BINARY ||
(src && !len))
return 0;
@@ -297,24 +338,42 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
-
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
- /*
- * If the file in the index has any CR in it, do not convert.
- * This is the new safer autocrlf handling.
- */
- if (checksafe == SAFE_CRLF_RENORMALIZE)
- checksafe = SAFE_CRLF_FALSE;
- else if (has_cr_in_index(path))
- return 0;
+ } else {
+ gather_stats(src, len, &stats, 0);
+ }
+ if (checksafe == SAFE_CRLF_RENORMALIZE) {
+ convert_crlf = 1;
+ checksafe = SAFE_CRLF_FALSE;
+ } else {
+ convert_crlf = would_convert_crlf_at_commit(path, &stats, len,
+ crlf_action);
}
- check_safe_crlf(path, crlf_action, &stats, checksafe);
- /* Optimization: No CRLF? Nothing to convert, regardless. */
- if (!stats.crlf)
+ if (checksafe) {
+ unsigned convert_stats = stats.stat_bits;
+ unsigned new_convert_stats = convert_stats;
+ /* Simulate commit */
+ if (convert_crlf &&
+ (new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_LF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_CRLF;
+ }
+ /* Simulate checkout */
+ if (would_convert_lf_at_checkout(new_convert_stats,
+ len, crlf_action)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_CRLF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_LF;
+ }
+ check_safe_crlf(path, crlf_action, checksafe,
+ convert_stats, new_convert_stats);
+ }
+ if (!convert_crlf)
return 0;
/*
@@ -328,7 +387,9 @@ 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 (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
/*
* If we guessed, we already know we rejected a file with
* lone CR, and we can strip a CR without looking at what
@@ -355,28 +416,15 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
- unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
-
-
- if (!len || output_eol(crlf_action) != EOL_CRLF)
+ unsigned earlyout = 0; /* Need to count lonelf */
+ if (!len)
return 0;
gather_stats(src, len, &stats, earlyout);
-
- /* No "naked" LF? Nothing to convert, regardless. */
- if (!stats.lonelf)
+ if (!would_convert_lf_at_checkout(stats.stat_bits,
+ len, crlf_action))
return 0;
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
-
- if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
- return 0;
- }
-
/* are we "faking" in place editing ? */
if (src == buf->buf)
to_free = strbuf_detach(buf, NULL);
@@ -1068,6 +1116,8 @@ int is_null_stream_filter(struct stream_filter *filter)
struct lf_to_crlf_filter {
struct stream_filter filter;
unsigned has_held:1;
+ unsigned expanded_loneLF:1;
+ unsigned had_CRLF:1;
char held;
};
@@ -1108,7 +1158,12 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
char ch = input[i];
if (ch == '\n') {
- output[o++] = '\r';
+ if (!lf_to_crlf->had_CRLF) {
+ output[o++] = '\r';
+ lf_to_crlf->expanded_loneLF = 1;
+ }
+ if (was_cr)
+ lf_to_crlf->had_CRLF = 1;
} else if (was_cr) {
/*
* Previous round saw CR and it is not followed
@@ -1137,6 +1192,14 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
was_cr = 0;
output[o++] = ch;
+ if (lf_to_crlf->expanded_loneLF &&
+ lf_to_crlf->had_CRLF) {
+ /*
+ * Mixed EOL, round trip not possible.
+ */
+ return 1;
+ }
+
}
*osize_p -= o;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index d0bee08..b5f93e2 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 "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'crlf=true causes a CRLF file to be normalized' '
+test_expect_success 'crlf=true causes a CRLF file not to be normalized' '
# Backwards compatibility check
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
@@ -49,10 +49,10 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
-test_expect_success 'text=true causes a CRLF file to be normalized' '
+test_expect_success 'text=true causes a CRLF file not to be normalized' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
echo "CRLFonly text" > .gitattributes &&
@@ -61,7 +61,7 @@ test_expect_success 'text=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 8367d0b..a16e513 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -71,10 +71,14 @@ check_warning () {
case "$1" in
LF_CRLF) echo "warning: LF will be replaced by CRLF" >"$2".expect ;;
CRLF_LF) echo "warning: CRLF will be replaced by LF" >"$2".expect ;;
+ CRLF) echo "warning: CRLF will be present after commit and checkout" >"$2".expect ;;
+ mixed) echo "warning: mixed eol will be present after commit and checkout" >"$2".expect ;;
'') >"$2".expect ;;
*) echo >&2 "Illegal 1": "$1" ; return false ;;
esac
- grep "will be replaced by" "$2" | sed -e "s/\(.*\) in [^ ]*$/\1/" | uniq >"$2".actual
+ egrep "will be replaced by|will be present after commit" "$2" |
+ sed -e "s/\(.*\) in [^ ]*$/\1/" |
+ uniq >"$2".actual
test_cmp "$2".expect "$2".actual
}
@@ -169,7 +173,7 @@ stats_ascii () {
# Take none (=empty), one or two args
# convert.c: eol=XX overrides text=auto
attr_ascii () {
- case $1,$2 in
+ case "$1","$2" in
-text,*) echo "-text" ;;
text,) echo "text" ;;
text,lf) echo "text eol=lf" ;;
@@ -349,10 +353,12 @@ then
WILC=LF_CRLF
WICL=
WAMIX=LF_CRLF
+ Pcrlf=
else
WILC=
WICL=CRLF_LF
WAMIX=CRLF_LF
+ Pcrlf=CRLF
fi
# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
@@ -392,31 +398,32 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
commit_chk_wrnNNO "" "" false "" "" "" "" ""
-commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "" "" input "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "" "" input "" CRLF mixed "" ""
+
+commit_chk_wrnNNO "auto" "" false "$WILC" "$Pcrlf" mixed "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF mixed "" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$Pcrlf" mixed "$WILC" "$Pcrlf"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" mixed LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF mixed "" CRLF
+
-commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
- commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
- commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" mixed LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF mixed "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" mixed "" ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" mixed LF_CRLF ""
done
-commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
-commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
-
test_expect_success 'create files cleanup' '
rm -f *.txt &&
git -c core.autocrlf=false reset --hard
@@ -456,9 +463,9 @@ do
check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
done
################################################################################
# Check how files in the repo are changed when they are checked out
@@ -479,12 +486,10 @@ done
if test_have_prereq NATIVE_CRLF
then
-MIX_CRLF_LF=CRLF
MIX_LF_CR=CRLF_mix_CR
NL=CRLF
LFNUL=CRLF_nul
else
-MIX_CRLF_LF=CRLF_mix_LF
MIX_LF_CR=LF_mix_CR
NL=LF
LFNUL=LF_nul
@@ -492,8 +497,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-#for id in "" ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
@@ -501,38 +505,38 @@ do
do
# -text overrides core.autocrlf and core.eol
# text and eol=crlf or eol=lf override core.autocrlf and core.eol
- checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text
- checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
- checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
- checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# core.autocrlf true
- checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
- checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text=auto + eol=XXX
done
# text: core.autocrlf=false uses core.eol
- checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false "" $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
+ checkout_files text "$id" "" false native $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v8 09/10] t6038; use crlf on all platforms
2016-03-07 22:34 ` Junio C Hamano
` (56 preceding siblings ...)
2016-04-29 15:02 ` [PATCH v8 08/10] convert.c: more safer crlf handling with text attribute tboegi
@ 2016-04-29 15:02 ` tboegi
2016-04-29 15:02 ` [PATCH v8 10/10] ce_compare_data() did not respect conversion tboegi
` (7 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-04-29 15:02 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
t6038 uses different code, dependig if NATIVE_CRLF is set ot not. When
the native line endings are LF, merge.renormalize is not tested very well.
Change the test to always use CRLF by setting core.eol=crlf.
After doing so, the test fails:
rm '.gitattributes'
rm 'control_file'
rm 'file'
rm 'inert_file'
HEAD is now at 0d9ffb6 add line from b
error: addinfo_cache failed for path 'file'
file: unmerged (cbd69ec7cd12dd0989e853923867d94c8519aa52)
file: unmerged (ad55e240aeb42e0d9a0e18d6d8b02dd82ee3e527)
file: unmerged (99b633103c15c20cebebf821133ab526b0ff90b2)
fatal: git write-tree failed to write a tree
Merging:
0d9ffb6 add line from b
virtual a
found 1 common ancestor:
1c56df1 Initial
Auto-merging file
not ok 4 - Merge addition of text=auto
This will be addressed in the next commit.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
t/t6038-merge-text-auto.sh | 37 +++++++++++--------------------------
1 file changed, 11 insertions(+), 26 deletions(-)
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 33b77ee..0108ead 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -25,6 +25,7 @@ compare_files () {
test_expect_success setup '
git config core.autocrlf false &&
+ git config core.eol crlf &&
echo first line | append_cr >file &&
echo first line >control_file &&
@@ -79,10 +80,8 @@ test_expect_success 'Merge after setting text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -97,10 +96,8 @@ test_expect_success 'Merge addition of text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -111,15 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected
- else
- echo first line >>expected &&
- echo same line >>expected &&
- echo ======= >>expected
- fi &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
+ echo ======= | append_cr >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -135,15 +126,9 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected
- else
- echo ======= >>expected &&
- echo first line >>expected &&
- echo same line >>expected
- fi &&
+ echo ======= | append_cr >>expected &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-03-07 22:34 ` Junio C Hamano
` (57 preceding siblings ...)
2016-04-29 15:02 ` [PATCH v8 09/10] t6038; use crlf on all platforms tboegi
@ 2016-04-29 15:02 ` tboegi
2016-04-29 18:20 ` Junio C Hamano
2016-04-29 21:09 ` Junio C Hamano
2016-05-07 6:10 ` [PATCH v9 0/6] convert-eol-autocrlf, old 5..10 now 1..6 tboegi
` (6 subsequent siblings)
65 siblings, 2 replies; 126+ messages in thread
From: tboegi @ 2016-04-29 15:02 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
We define the working tree file is clean if either:
* the result of running convert_to_git() on the working tree
contents matches what is in the index (because that would mean
doing another "git add" on the path is a no-op); OR
* the result of running convert_to_working_tree() on the content
in the index matches what is in the working tree (because that
would mean doing another "git checkout -f" on the path is a
no-op).
Add an extra check in ce_compare_data() in read_cache.c.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
read-cache.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++
t/t6038-merge-text-auto.sh | 14 +++++------
2 files changed, 68 insertions(+), 7 deletions(-)
diff --git a/read-cache.c b/read-cache.c
index a3ef967..48c4b31 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -156,17 +156,78 @@ void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
ce_mark_uptodate(ce);
}
+/*
+ * Compare the data in buf with the data in the file pointed by fd and
+ * return 0 if they are identical, and non-zero if they differ.
+ */
+static int compare_with_fd(const char *input, ssize_t len, int fd)
+{
+ for (;;) {
+ char buf[1024 * 16];
+ ssize_t chunk_len, read_len;
+
+ chunk_len = sizeof(buf) < len ? sizeof(buf) : len;
+ read_len = xread(fd, buf, chunk_len ? chunk_len : 1);
+
+ if (!read_len)
+ /* EOF on the working tree file */
+ return !len ? 0 : -1;
+
+ if (!len)
+ /* we expected there is nothing left */
+ return -1;
+
+ if (memcmp(buf, input, read_len))
+ return -1;
+ input += read_len;
+ len -= read_len;
+ }
+}
+
static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
{
int match = -1;
int fd = open(ce->name, O_RDONLY);
+ /*
+ * Would another "git add" on the path change what is in the
+ * index for the path?
+ */
if (fd >= 0) {
unsigned char sha1[20];
if (!index_fd(sha1, fd, st, OBJ_BLOB, ce->name, 0))
match = hashcmp(sha1, ce->sha1);
/* index_fd() closed the file descriptor already */
}
+ if (!match)
+ return match;
+
+ /*
+ * Would another "git checkout -f" out of the index change
+ * what is in the working tree file?
+ */
+ fd = open(ce->name, O_RDONLY);
+ if (fd >= 0) {
+ enum object_type type;
+ unsigned long size_long;
+ void *data = read_sha1_file(ce->sha1, &type, &size_long);
+
+ if (type == OBJ_BLOB) {
+ struct strbuf worktree = STRBUF_INIT;
+ if (convert_to_working_tree(ce->name, data,
+ size_long,
+ &worktree)) {
+ size_t size;
+ free(data);
+ data = strbuf_detach(&worktree, &size);
+ size_long = size;
+ }
+ if (!compare_with_fd(data, size_long, fd))
+ match = 0;
+ }
+ free(data);
+ close(fd);
+ }
return match;
}
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 0108ead..565daf3 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -108,9 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
+ echo ======= >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -121,14 +121,13 @@ test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
fuzz_conflict file >file.fuzzy &&
compare_files expected file.fuzzy
'
-
test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
+ echo ======= >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
@@ -138,6 +137,7 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
compare_files expected file.fuzzy
'
+
test_expect_failure 'checkout -m after setting text=auto' '
cat <<-\EOF >expected &&
first line
--
2.7.0.992.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-04-29 15:02 ` [PATCH v8 10/10] ce_compare_data() did not respect conversion tboegi
@ 2016-04-29 18:20 ` Junio C Hamano
2016-04-29 21:09 ` Junio C Hamano
1 sibling, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-04-29 18:20 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> We define the working tree file is clean if either:
>
> * the result of running convert_to_git() on the working tree
> contents matches what is in the index (because that would mean
> doing another "git add" on the path is a no-op); OR
>
> * the result of running convert_to_working_tree() on the content
> in the index matches what is in the working tree (because that
> would mean doing another "git checkout -f" on the path is a
> no-op).
>
> Add an extra check in ce_compare_data() in read_cache.c.
>
> Helped-by: Junio C Hamano <gitster@pobox.com>
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
> ---
Thanks, will re-queue.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-04-29 15:02 ` [PATCH v8 10/10] ce_compare_data() did not respect conversion tboegi
2016-04-29 18:20 ` Junio C Hamano
@ 2016-04-29 21:09 ` Junio C Hamano
2016-05-01 16:27 ` Torsten Bögershausen
1 sibling, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-04-29 21:09 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> We define the working tree file is clean if either:
>
> * the result of running convert_to_git() on the working tree
> contents matches what is in the index (because that would mean
> doing another "git add" on the path is a no-op); OR
>
> * the result of running convert_to_working_tree() on the content
> in the index matches what is in the working tree (because that
> would mean doing another "git checkout -f" on the path is a
> no-op).
>
> Add an extra check in ce_compare_data() in read_cache.c.
>
> Helped-by: Junio C Hamano <gitster@pobox.com>
Well, didn't I do exactly the above much earlier and discarded it
because that breaks the definition of "diff"? Or is this doing
something differently?
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-04-29 21:09 ` Junio C Hamano
@ 2016-05-01 16:27 ` Torsten Bögershausen
2016-05-02 18:16 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Torsten Bögershausen @ 2016-05-01 16:27 UTC (permalink / raw)
To: Junio C Hamano, tboegi; +Cc: git
On 29.04.16 23:09, Junio C Hamano wrote:
> Well, didn't I do exactly the above much earlier and discarded it
> because that breaks the definition of "diff"? Or is this doing
> something differently?
Yes, and I try to sneak it in anyway ;-)
I spend some time debugging how to get t6038 passed, and need
some more time.
If 10/10 is a no-go (and it probably should be),
does it make sense to keep 1/10..4/10 and discard 5..10 for the moment ?
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-05-01 16:27 ` Torsten Bögershausen
@ 2016-05-02 18:16 ` Junio C Hamano
2016-05-02 19:33 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-05-02 18:16 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
> On 29.04.16 23:09, Junio C Hamano wrote:
>
>> Well, didn't I do exactly the above much earlier and discarded it
>> because that breaks the definition of "diff"? Or is this doing
>> something differently?
>
> Yes, and I try to sneak it in anyway ;-)
>
> I spend some time debugging how to get t6038 passed, and need
> some more time.
>
> If 10/10 is a no-go (and it probably should be),
> does it make sense to keep 1/10..4/10 and discard 5..10 for the moment ?
Earlier patches in the series certainly felt alright. I do not
remember noticing where it went in a strange direction to be honest.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-05-02 18:16 ` Junio C Hamano
@ 2016-05-02 19:33 ` Junio C Hamano
2016-05-03 16:02 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-05-02 19:33 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Junio C Hamano <gitster@pobox.com> writes:
> Torsten Bögershausen <tboegi@web.de> writes:
>
>> On 29.04.16 23:09, Junio C Hamano wrote:
>>
>>> Well, didn't I do exactly the above much earlier and discarded it
>>> because that breaks the definition of "diff"? Or is this doing
>>> something differently?
>>
>> Yes, and I try to sneak it in anyway ;-)
>>
>> I spend some time debugging how to get t6038 passed, and need
>> some more time.
>>
>> If 10/10 is a no-go (and it probably should be),
>> does it make sense to keep 1/10..4/10 and discard 5..10 for the moment ?
>
> Earlier patches in the series certainly felt alright. I do not
> remember noticing where it went in a strange direction to be honest.
Let's step back a bit and make sure we are on the same page. I
think this "series" conflates a bit too many things into a single
topic.
* The comparison between the index and the working tree, i.e. "git
diff", should compare result of convert_to_git() with what is in
the index, and the world around it should be made consistent with
that. Your separate "git blame" fix to add missing knowledge
that convert_to_git() would not do s/CRLF/LF/ for a path whose
index entry already is contaminated with CR falls into this
category and was a very good thing to do.
* A convert_to_git() and convert_to_working_tree() pair that do not
roundtrip would (by definition) leave contents in the working
tree, that, when passed through convert_to_git(), will be
different from the index, upon completion of "reset --hard". We
_should_ fix it so that "git diff" _reports_ differences.
Currently, lstat(2) based optimization hides this in a racy way
(when racy Git kicks in to reinspect the index and the working
tree file actually matches, it finds out that they do not match),
it is a bug that needs to be fixed, not 10/10 where it tries to
hide the differences consistently and spreads the bug. I haven't
studied 8/10 carefully yet, but it seems to attempt the same.
* I think the "text=auto eol=THIS" that did not mean "I do not care
to specify which ones are text files. Please detect the file
type, and for those automatically detected, please make sure that
the contents follwo THIS eol convention." was a bug, and what
07/10 tries to do is a good thing.
By the way, lack of the cover letter of this series made it more
painful to write a reply like this than necessary. A cover letter
for a trivial 3-patch series might be overkill, but for anything
with substance that spans more than 4-5 patches, a cover letter to
describe the overall direction would really help.
Thanks.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-05-02 19:33 ` Junio C Hamano
@ 2016-05-03 16:02 ` Torsten Bögershausen
2016-05-03 18:31 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Torsten Bögershausen @ 2016-05-03 16:02 UTC (permalink / raw)
To: Junio C Hamano, Torsten Bögershausen; +Cc: git
On 2016-05-02 21.33, Junio C Hamano wrote:
> Junio C Hamano <gitster@pobox.com> writes:
> Let's step back a bit and make sure we are on the same page. I
> think this "series" conflates a bit too many things into a single
> topic.
>
> * The comparison between the index and the working tree, i.e. "git
> diff", should compare result of convert_to_git() with what is in
> the index, and the world around it should be made consistent with
> that. Your separate "git blame" fix to add missing knowledge
> that convert_to_git() would not do s/CRLF/LF/ for a path whose
> index entry already is contaminated with CR falls into this
> category and was a very good thing to do.
>
> * A convert_to_git() and convert_to_working_tree() pair that do not
> roundtrip would (by definition) leave contents in the working
> tree, that, when passed through convert_to_git(), will be
> different from the index, upon completion of "reset --hard". We
> _should_ fix it so that "git diff" _reports_ differences.
> Currently, lstat(2) based optimization hides this in a racy way
> (when racy Git kicks in to reinspect the index and the working
> tree file actually matches, it finds out that they do not match),
> it is a bug that needs to be fixed, not 10/10 where it tries to
> hide the differences consistently and spreads the bug. I haven't
> studied 8/10 carefully yet, but it seems to attempt the same.
>
> * I think the "text=auto eol=THIS" that did not mean "I do not care
> to specify which ones are text files. Please detect the file
> type, and for those automatically detected, please make sure that
> the contents follwo THIS eol convention." was a bug, and what
> 07/10 tries to do is a good thing.
>
> By the way, lack of the cover letter of this series made it more
> painful to write a reply like this than necessary. A cover letter
> for a trivial 3-patch series might be overkill, but for anything
> with substance that spans more than 4-5 patches, a cover letter to
> describe the overall direction would really help.
The 10/10 needs to be replaced with something different, and I start to
get a better picture, why.
read_cache.c/ce_compare_data() checks what "git add" will change in the index.
sha1_file.c/index_fd() will read the file content from the working tree,
run convert_to_git() and calculate the sha1, which read_cache.c feeds into
hashcmp().
When convert_to_git() is run, 3 steps are taken:
- apply the filter, if any
- run crlf_to_git(), if attributes and core.autocrlf say so
- run ident, if specified.
Now the crlf_to_git() uses has_cr_in_index(const char *path) to find
out if we should keep the CRLF or not.
Side note: the suggested patches will use
get_convert_stats_sha1(get_sha1_from_cache(path),)
This works pretty well under normal "git add", but fails in t6038,
when we do a merge.
The new function get_sha1_from_index() can not find the sha1,
"read-cache.c/get_sha1_from_index:2392 path=file pos=-3"
and falls into the code path for
/*
* We might be in the middle of a merge, in which
* case we would read stage #2 (ours).
*/
read-cache.c/get_sha1_from_index:2408 path=file pos=3
read-cache.c/get_sha1_from_index:2416 path=file sha1=ad55e2
(The line number are with debug code)
The problem is, that ad55e2 is _not_ the sha1, which
read_cache/ce_compare_data() had been asked to look at.
Instead we should check the blob with 99b633.
The result is that convert/get_convert_stats_sha1() is called on the
wrong blob (the one with CRLF instead the one without CRLF), and this
makes t6038 from 9/10 fail.
10/10 rescues the situation, by using the correct blob :-)
In short, ce_compare_data() needs to forward ce->sha1 the whole way into
convert.c/crlf_to_git() and get_convert_stats_sha1().
While at it, I realized that we call a convert_attrs(&ca, path) a couple
of times (e.g. in would_convert_to_git(), to find out that we really don't have
any attributes set.
It could be nice to do that only once.
The next step will be to add the improvements/fixes for the ce_compare_data()
chain as described above, and then put 7/10..9/10 on top of that.
This will probably take some time, so that's why I asked if 1/10..4/10 could
proceed as is ?
(and the next version with cover letter, sorry for that)
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-05-03 16:02 ` Torsten Bögershausen
@ 2016-05-03 18:31 ` Junio C Hamano
2016-05-04 4:07 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-05-03 18:31 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
> This will probably take some time, so that's why I asked if 1/10..4/10 could
> proceed as is ?
Sure, I wasn't saying 1-4 looked wrong at all. I was wondering why
the ones in the middle, especially 7, shouldn't be moved forward
together with them.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-05-03 18:31 ` Junio C Hamano
@ 2016-05-04 4:07 ` Torsten Bögershausen
2016-05-04 7:23 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Torsten Bögershausen @ 2016-05-04 4:07 UTC (permalink / raw)
To: Junio C Hamano, Torsten Bögershausen; +Cc: git
On 05/03/2016 08:31 PM, Junio C Hamano wrote:
> Torsten Bögershausen <tboegi@web.de> writes:
>
>> This will probably take some time, so that's why I asked if 1/10..4/10 could
>> proceed as is ?
> Sure, I wasn't saying 1-4 looked wrong at all. I was wondering why
> the ones in the middle, especially 7, shouldn't be moved forward
> together with them.
The main reason is, that 7 breaks t6038 under Windows.
(And I discovered that too late :-(
And as Windows is the platform being most interested in CRLF handling,
I need to re-do some work.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-05-04 4:07 ` Torsten Bögershausen
@ 2016-05-04 7:23 ` Junio C Hamano
2016-05-06 8:54 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-05-04 7:23 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
>> Sure, I wasn't saying 1-4 looked wrong at all. I was wondering why
>> the ones in the middle, especially 7, shouldn't be moved forward
>> together with them.
> The main reason is, that 7 breaks t6038 under Windows.
> (And I discovered that too late :-(
> And as Windows is the platform being most interested in CRLF handling,
> I need to re-do some work.
OK.
Let's separate 01-04/10 into a different topic and give it its own
name; tb/convert-eol-autocrlf was the name I picked primarily for
07/10 but 01-04/10 are not about that fix. Both 02 and 04 are about
autocrlf (the former is "core.eol is irrelevant when core.autocrlf
is there", the latter is "fix core.autocrlf used in conjunction with
ident conversion"), so how about tb/autocrlf-fix or something?
And then we can merge that to 'next' and to 'master' while we find
solution to 07/10 which is really the more important bit.
As to (the inverse of) 10/10, I am starting to suspect that the
correct solution (which may not be the "right" one, though) would
involve teaching write_entry() that not everything it writes out can
be marked up-to-date in the index. A naive implemention would be to
pass what it writes out to the filesystem through convert_to_git()
and see if the result matches the blob in the index, and if it does
not match, make sure ce_mark_uptodate() is not called, perhaps by
not calling fill_stat_cache_info(), or manually dropping CE_UPTODATE
bit at the end of the function.
A naive implementation however may turn out to be way too expensive
to use as-is, I am afraid. Possible ways to speed up would be to
skip this "refrain from marking up-to-date" hackery when conversion
is known to be well behaved. For example, with the EOL handling
updated with your series, we may be able to say that the stock
to-git and to-working-tree pair is guaranteed to roundtrip even with
EOL conversion, ident conversion as long as there is no end-user
defined clean/smudge filters. With such an optimization, the result
might perform with acceptable performance penalty in common cases.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-05-04 7:23 ` Junio C Hamano
@ 2016-05-06 8:54 ` Torsten Bögershausen
2016-05-06 17:11 ` Junio C Hamano
0 siblings, 1 reply; 126+ messages in thread
From: Torsten Bögershausen @ 2016-05-06 8:54 UTC (permalink / raw)
To: Junio C Hamano, Torsten Bögershausen; +Cc: git
> Let's separate 01-04/10 into a different topic and give it its own
> name; tb/convert-eol-autocrlf was the name I picked primarily for
> 07/10 but 01-04/10 are not about that fix. Both 02 and 04 are about
> autocrlf (the former is "core.eol is irrelevant when core.autocrlf
> is there", the latter is "fix core.autocrlf used in conjunction with
> ident conversion"), so how about tb/autocrlf-fix or something?
tb/core-eol-fix would be my suggestion, or core-eol-t0027-fix.
> And then we can merge that to 'next' and to 'master' while we find
> solution to 07/10 which is really the more important bit.
>
> As to (the inverse of) 10/10, I am starting to suspect that the
> correct solution (which may not be the "right" one, though) would
> involve teaching write_entry() that not everything it writes out can
> be marked up-to-date in the index. A naive implemention would be to
> pass what it writes out to the filesystem through convert_to_git()
> and see if the result matches the blob in the index, and if it does
> not match, make sure ce_mark_uptodate() is not called, perhaps by
> not calling fill_stat_cache_info(), or manually dropping CE_UPTODATE
> bit at the end of the function.
>
> A naive implementation however may turn out to be way too expensive
> to use as-is, I am afraid. Possible ways to speed up would be to
> skip this "refrain from marking up-to-date" hackery when conversion
> is known to be well behaved. For example, with the EOL handling
> updated with your series, we may be able to say that the stock
> to-git and to-working-tree pair is guaranteed to roundtrip even with
> EOL conversion, ident conversion as long as there is no end-user
> defined clean/smudge filters. With such an optimization, the result
> might perform with acceptable performance penalty in common cases.
>
That makes sense and will remove the shakiness, right ?
We only need to pay extra attention when there is an
external clean/smudge filter defined - otherwise we should be able to skip it -
after 10/10.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 10/10] ce_compare_data() did not respect conversion
2016-05-06 8:54 ` Torsten Bögershausen
@ 2016-05-06 17:11 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-05-06 17:11 UTC (permalink / raw)
To: Torsten Bögershausen; +Cc: git
Torsten Bögershausen <tboegi@web.de> writes:
> We only need to pay extra attention when there is an external
> clean/smudge filter defined - otherwise we should be able to skip
> it - after 10/10.
The last two words worries me. The goal of the suggested fix was to
make sure that
$ git reset --hard && git diff
reports that there _are_ differences in the working tree files, if
the to-git and to-working-tree conversion do not round-trip. It is
a total opposite of 10/10, which hides the fact that working tree
contents, if added to the index, would change the index.
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH v9 0/6] convert-eol-autocrlf, old 5..10 now 1..6
2016-03-07 22:34 ` Junio C Hamano
` (58 preceding siblings ...)
2016-04-29 15:02 ` [PATCH v8 10/10] ce_compare_data() did not respect conversion tboegi
@ 2016-05-07 6:10 ` tboegi
2016-05-07 6:10 ` [PATCH v9 1/6] read-cache: factor out get_sha1_from_index() helper tboegi
` (5 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-05-07 6:10 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Changes since v8:
As discussed earlier, 1..4 should be broken out into
tb/autocrlf-fix or so.
1..4 are not part of this series any more.
The old 10/10 is now 6/6.
It is replaced by "ce_compare_data() checks for a sha1 of a path"
It now checks for "What would git add change in the index",
and not "is the working tree clean after checkout" -
thats how it should be.
Basically an old limititation of "has_crlf_in_index()" has been found and
fixed.
The commit message may need some tweaking, and
even the implementation, so feedback is welcome.
Beside that, I haven't run the tests under Windows yet.
Torsten Bögershausen (6):
read-cache: factor out get_sha1_from_index() helper
convert.c: stream and early out
convert: unify the "auto" handling of CRLF
convert.c: more safer crlf handling with text attribute
t6038; use crlf on all platforms
convert: ce_compare_data() checks for a sha1 of a path
Documentation/config.txt | 14 +-
Documentation/gitattributes.txt | 24 ++-
cache.h | 4 +
convert.c | 362 +++++++++++++++++++++++++++-------------
convert.h | 26 ++-
read-cache.c | 33 ++--
sha1_file.c | 17 +-
t/t0025-crlf-auto.sh | 12 +-
t/t0027-auto-crlf.sh | 98 +++++------
t/t6038-merge-text-auto.sh | 60 +++----
10 files changed, 407 insertions(+), 243 deletions(-)
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH v9 1/6] read-cache: factor out get_sha1_from_index() helper
2016-03-07 22:34 ` Junio C Hamano
` (59 preceding siblings ...)
2016-05-07 6:10 ` [PATCH v9 0/6] convert-eol-autocrlf, old 5..10 now 1..6 tboegi
@ 2016-05-07 6:10 ` tboegi
2016-05-09 19:54 ` Junio C Hamano
2016-05-07 6:11 ` [PATCH v9 2/6] convert.c: stream and early out tboegi
` (4 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-05-07 6:10 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Factor out the retrieval of the sha1 for a given path in
read_blob_data_from_index() into the function get_sha1_from_index().
This will be used in the next commit, when convert.c can do the
analyze for "text=auto" without slurping the whole blob into memory
at once.
Add a wrapper definition get_sha1_from_cache().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
cache.h | 3 +++
read-cache.c | 29 ++++++++++++++++++-----------
2 files changed, 21 insertions(+), 11 deletions(-)
diff --git a/cache.h b/cache.h
index 1c60918..28f23d7 100644
--- a/cache.h
+++ b/cache.h
@@ -379,6 +379,7 @@ extern void free_name_hash(struct index_state *istate);
#define unmerge_cache_entry_at(at) unmerge_index_entry_at(&the_index, at)
#define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)
#define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))
+#define get_sha1_from_cache(path) get_sha1_from_index (&the_index, (path))
#endif
enum object_type {
@@ -1019,6 +1020,8 @@ static inline void *read_sha1_file(const unsigned char *sha1, enum object_type *
return read_sha1_file_extended(sha1, type, size, LOOKUP_REPLACE_OBJECT);
}
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path);
+
/*
* This internal function is only declared here for the benefit of
* lookup_replace_object(). Please do not call it directly.
diff --git a/read-cache.c b/read-cache.c
index d9fb78b..a3ef967 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -2263,13 +2263,27 @@ int index_name_is_other(const struct index_state *istate, const char *name,
void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
{
- int pos, len;
+ const unsigned char *sha1;
unsigned long sz;
enum object_type type;
void *data;
- len = strlen(path);
- pos = index_name_pos(istate, path, len);
+ sha1 = get_sha1_from_index(istate, path);
+ if (!sha1)
+ return NULL;
+ data = read_sha1_file(sha1, &type, &sz);
+ if (!data || type != OBJ_BLOB) {
+ free(data);
+ return NULL;
+ }
+ if (size)
+ *size = sz;
+ return data;
+}
+
+const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path)
+{
+ int pos = index_name_pos(istate, path, strlen(path));
if (pos < 0) {
/*
* We might be in the middle of a merge, in which
@@ -2285,14 +2299,7 @@ void *read_blob_data_from_index(struct index_state *istate, const char *path, un
}
if (pos < 0)
return NULL;
- data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
- if (!data || type != OBJ_BLOB) {
- free(data);
- return NULL;
- }
- if (size)
- *size = sz;
- return data;
+ return (istate->cache[pos]->sha1);
}
void stat_validity_clear(struct stat_validity *sv)
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v9 2/6] convert.c: stream and early out
2016-03-07 22:34 ` Junio C Hamano
` (60 preceding siblings ...)
2016-05-07 6:10 ` [PATCH v9 1/6] read-cache: factor out get_sha1_from_index() helper tboegi
@ 2016-05-07 6:11 ` tboegi
2016-05-09 20:29 ` Junio C Hamano
2016-05-07 6:11 ` [PATCH v9 3/6] convert: unify the "auto" handling of CRLF tboegi
` (3 subsequent siblings)
65 siblings, 1 reply; 126+ messages in thread
From: tboegi @ 2016-05-07 6:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
When statistics are done for the autocrlf handling, the search in
the content can be stopped, if e.g
- a search for binary is done, and a NUL character is found
- a search for CRLF is done, and the first CRLF is found.
Similar when statistics for binary vs non-binary are gathered:
Whenever a lone CR or NUL is found, the search can be aborted.
When checking out files in "auto" mode, any file that has a "lone CR"
or a CRLF will not be converted, so the search can be aborted early.
Add the new bit, CONVERT_STAT_BITS_ANY_CR,
which is set for either lone CR or CRLF.
Many binary files have a NUL very early (within the first few bytes,
latest within the first 1..2K).
It is often not necessary to load the whole content of a file or blob
into memory.
Use a streaming handling for blobs and files in the worktree.
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
convert.c | 159 ++++++++++++++++++++++++++++++++++++++++----------------------
1 file changed, 103 insertions(+), 56 deletions(-)
diff --git a/convert.c b/convert.c
index b1614bf..24ab095 100644
--- a/convert.c
+++ b/convert.c
@@ -3,6 +3,7 @@
#include "run-command.h"
#include "quote.h"
#include "sigchain.h"
+#include "streaming.h"
/*
* convert.c - convert a file when checking it out and checking it in.
@@ -13,10 +14,10 @@
* translation when the "text" attribute or "auto_crlf" option is set.
*/
-/* Stat bits: When BIN is set, the txt bits are unset */
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
+#define CONVERT_STAT_BITS_ANY_CR 0x8
enum crlf_action {
CRLF_UNDEFINED,
@@ -31,30 +32,36 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned nul, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonecr, lonelf, crlf;
/* These are just approximations! */
unsigned printable, nonprintable;
};
-static void gather_stats(const char *buf, unsigned long size, struct text_stat *stats)
+static void do_gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
{
unsigned long i;
- memset(stats, 0, sizeof(*stats));
-
+ if (!buf || !size)
+ return;
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
+ stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
stats->crlf++;
i++;
- } else
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
+ } else {
stats->lonecr++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+ }
continue;
}
if (c == '\n') {
stats->lonelf++;
+ stats->stat_bits |= CONVERT_STAT_BITS_TXT_LF;
continue;
}
if (c == 127)
@@ -67,7 +74,7 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
stats->printable++;
break;
case 0:
- stats->nul++;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
/* fall through */
default:
stats->nonprintable++;
@@ -75,6 +82,8 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
}
else
stats->printable++;
+ if (stats->stat_bits & earlyout)
+ break; /* We found what we have been searching for */
}
/* If file ends with EOF then don't count this EOF as non-printable. */
@@ -86,41 +95,62 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
* The same heuristics as diff.c::mmfile_is_binary()
* We treat files with bare CR as binary
*/
-static int convert_is_binary(unsigned long size, const struct text_stat *stats)
+static void convert_nonprintable(struct text_stat *stats)
{
- if (stats->lonecr)
- return 1;
- if (stats->nul)
- return 1;
if ((stats->printable >> 7) < stats->nonprintable)
- return 1;
- return 0;
+ stats->stat_bits |= CONVERT_STAT_BITS_BIN;
+}
+
+static void gather_stats(const char *buf, unsigned long size,
+ struct text_stat *stats, unsigned earlyout)
+{
+ memset(stats, 0, sizeof(*stats));
+ do_gather_stats(buf, size, stats, earlyout);
+ convert_nonprintable(stats);
}
-static unsigned int gather_convert_stats(const char *data, unsigned long size)
+
+static unsigned get_convert_stats_sha1(unsigned const char *sha1,
+ unsigned earlyout)
{
+ struct git_istream *st;
struct text_stat stats;
- int ret = 0;
- if (!data || !size)
- return 0;
- gather_stats(data, size, &stats);
- if (convert_is_binary(size, &stats))
- ret |= CONVERT_STAT_BITS_BIN;
- if (stats.crlf)
- ret |= CONVERT_STAT_BITS_TXT_CRLF;
- if (stats.lonelf)
- ret |= CONVERT_STAT_BITS_TXT_LF;
+ enum object_type type;
+ unsigned long sz;
- return ret;
+ if (!sha1)
+ return 0;
+ memset(&stats, 0, sizeof(stats));
+ st = open_istream(sha1, &type, &sz, NULL);
+ if (!st) {
+ return 0;
+ }
+ if (type != OBJ_BLOB)
+ goto close_and_exit_i;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read_istream(st, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+close_and_exit_i:
+ close_istream(st);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
}
-static const char *gather_convert_stats_ascii(const char *data, unsigned long size)
+static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned int convert_stats = gather_convert_stats(data, size);
-
+ unsigned mask = CONVERT_STAT_BITS_TXT_LF |
+ CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats) {
+ switch (convert_stats & mask) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -132,24 +162,45 @@ static const char *gather_convert_stats_ascii(const char *data, unsigned long si
}
}
+static unsigned get_convert_stats_wt(const char *path)
+{
+ struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ int fd;
+ memset(&stats, 0, sizeof(stats));
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ return 0;
+ for (;;) {
+ char buf[1024];
+ ssize_t readlen = read(fd, buf, sizeof(buf));
+ if (readlen < 0)
+ break;
+ if (!readlen)
+ break;
+ do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
+ if (stats.stat_bits & earlyout)
+ break; /* We found what we have been searching for */
+ }
+ close(fd);
+ convert_nonprintable(&stats);
+ return stats.stat_bits;
+}
+
const char *get_cached_convert_stats_ascii(const char *path)
{
- const char *ret;
- unsigned long sz;
- void *data = read_blob_data_from_cache(path, &sz);
- ret = gather_convert_stats_ascii(data, sz);
- free(data);
- return ret;
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
}
const char *get_wt_convert_stats_ascii(const char *path)
{
- const char *ret = "";
- struct strbuf sb = STRBUF_INIT;
- if (strbuf_read_file(&sb, path, 0) >= 0)
- ret = gather_convert_stats_ascii(sb.buf, sb.len);
- strbuf_release(&sb);
- return ret;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_wt(path);
+ return convert_stats_ascii(convert_stats);
}
static int text_eol_is_crlf(void)
@@ -219,16 +270,10 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
static int has_cr_in_index(const char *path)
{
- unsigned long sz;
- void *data;
- int has_cr;
-
- data = read_blob_data_from_cache(path, &sz);
- if (!data)
- return 0;
- has_cr = memchr(data, '\r', sz) != NULL;
- free(data);
- return has_cr;
+ unsigned convert_stats;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_ANY_CR);
+ return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -249,10 +294,10 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
@@ -309,11 +354,13 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
+ unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
+
if (!len || output_eol(crlf_action) != EOL_CRLF)
return 0;
- gather_stats(src, len, &stats);
+ gather_stats(src, len, &stats, earlyout);
/* No "naked" LF? Nothing to convert, regardless. */
if (!stats.lonelf)
@@ -327,7 +374,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
}
- if (convert_is_binary(len, &stats))
+ if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
}
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v9 3/6] convert: unify the "auto" handling of CRLF
2016-03-07 22:34 ` Junio C Hamano
` (61 preceding siblings ...)
2016-05-07 6:11 ` [PATCH v9 2/6] convert.c: stream and early out tboegi
@ 2016-05-07 6:11 ` tboegi
2016-05-07 6:11 ` [PATCH v9 4/6] convert.c: more safer crlf handling with text attribute tboegi
` (2 subsequent siblings)
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-05-07 6:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Before this change,
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
would have the same effect as
$ echo "* text" >.gitattributes
$ git config core.eol crlf
Since the 'eol' attribute had higher priority than 'text=auto', this may
corrupt binary files and is not what most users expect to happen.
Make the 'eol' attribute to obey 'text=auto', and now
$ echo "* text=auto" >.gitattributes
$ echo "* eol=crlf" >>.gitattributes
behaves the same as
$ echo "* text=auto" >.gitattributes
$ git config core.eol crlf
In other words,
$ echo "* text=auto eol=crlf" >.gitattributes
has the same effect as
$ git config core.autocrlf true
and
$ echo "* text=auto eol=lf" >.gitattributes
has the same effect as
$ git config core.autocrlf input
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/config.txt | 14 +++++++-------
Documentation/gitattributes.txt | 15 +++++++++------
convert.c | 42 +++++++++++++++++++++--------------------
convert.h | 3 ++-
t/t0025-crlf-auto.sh | 4 ++--
t/t0027-auto-crlf.sh | 32 +++++++++++++++----------------
t/t6038-merge-text-auto.sh | 23 ++++++++++++++--------
7 files changed, 73 insertions(+), 60 deletions(-)
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 988ea1e..4c47a25 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -397,13 +397,13 @@ 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',
+ Setting this variable to "true" is the same as setting
+ the `text` attribute to "auto" on all files and core.eol to "crlf".
+ Set to true if you want to have `CRLF` line endings in your
+ working directory and the repository has LF line endings.
+ Text files are guaranteed not to be normalized: files that contain
+ `CRLF` in the repository will not be touched.
+ This variable can be set to 'input',
in which case no output conversion is performed.
core.symlinks::
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index e3b1de8..d7a124b 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -115,6 +115,7 @@ 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.eol` configuration variable for all text files.
+Note that `core.autocrlf` overrides `core.eol`
Set::
@@ -130,8 +131,9 @@ Unset::
Set to string value "auto"::
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.
+ end-of-line conversion. If Git decides that the content is
+ text, its line endings are converted to LF on checkin.
+ When the file has been commited with CRLF, no conversion is done.
Unspecified::
@@ -146,7 +148,7 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line normalization without any
+working directory. It enables end-of-line conversion without any
content checks, effectively setting the `text` attribute.
Set to string value "crlf"::
@@ -186,9 +188,10 @@ the working directory, and prevent .jpg files from being normalized
regardless of their content.
------------------------
+* text=auto
*.txt text
-*.vcproj eol=crlf
-*.sh eol=lf
+*.vcproj text eol=crlf
+*.sh text eol=lf
*.jpg -text
------------------------
@@ -198,7 +201,7 @@ 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.
+config variable "core.autocrlf" without using any attributes.
------------------------
[core]
diff --git a/convert.c b/convert.c
index 24ab095..3782172 100644
--- a/convert.c
+++ b/convert.c
@@ -227,7 +227,9 @@ static enum eol output_eol(enum crlf_action crlf_action)
return EOL_LF;
case CRLF_UNDEFINED:
case CRLF_AUTO_CRLF:
+ return EOL_CRLF;
case CRLF_AUTO_INPUT:
+ return EOL_LF;
case CRLF_TEXT:
case CRLF_AUTO:
/* fall through */
@@ -299,17 +301,15 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
-
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /*
- * 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 the file in the index has any CR in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ if (checksafe == SAFE_CRLF_RENORMALIZE)
+ checksafe = SAFE_CRLF_FALSE;
+ else if (has_cr_in_index(path))
+ return 0;
}
-
check_safe_crlf(path, crlf_action, &stats, checksafe);
/* Optimization: No CRLF? Nothing to convert, regardless. */
@@ -367,12 +367,10 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
return 0;
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
- }
+ /* If we have any CR or CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (stats.lonecr || stats.crlf )
+ return 0;
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
@@ -833,7 +831,11 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
ca->drv = git_path_check_convert(ccheck + 2);
if (ca->crlf_action != CRLF_BINARY) {
enum eol eol_attr = git_path_check_eol(ccheck + 3);
- if (eol_attr == EOL_LF)
+ if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_LF)
+ ca->crlf_action = CRLF_AUTO_INPUT;
+ else if (ca->crlf_action == CRLF_AUTO && eol_attr == EOL_CRLF)
+ ca->crlf_action = CRLF_AUTO_CRLF;
+ else if (eol_attr == EOL_LF)
ca->crlf_action = CRLF_TEXT_INPUT;
else if (eol_attr == EOL_CRLF)
ca->crlf_action = CRLF_TEXT_CRLF;
@@ -892,9 +894,9 @@ const char *get_convert_attr_ascii(const char *path)
case CRLF_AUTO:
return "text=auto";
case CRLF_AUTO_CRLF:
- return "text=auto eol=crlf"; /* This is not supported yet */
+ return "text=auto eol=crlf";
case CRLF_AUTO_INPUT:
- return "text=auto eol=lf"; /* This is not supported yet */
+ return "text=auto eol=lf";
}
return "";
}
@@ -996,7 +998,7 @@ int renormalize_buffer(const char *path, const char *src, size_t len, struct str
src = dst->buf;
len = dst->len;
}
- return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_FALSE);
+ return ret | convert_to_git(path, src, len, dst, SAFE_CRLF_RENORMALIZE);
}
/*****************************************************************
diff --git a/convert.h b/convert.h
index ccf436b..81b6cdf 100644
--- a/convert.h
+++ b/convert.h
@@ -7,7 +7,8 @@
enum safe_crlf {
SAFE_CRLF_FALSE = 0,
SAFE_CRLF_FAIL = 1,
- SAFE_CRLF_WARN = 2
+ SAFE_CRLF_WARN = 2,
+ SAFE_CRLF_RENORMALIZE = 4
};
extern enum safe_crlf safe_crlf;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index c164b46..d0bee08 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -114,7 +114,7 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
+test_expect_success 'text=auto, autocrlf=true does not normalize CRLF files' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
git config core.autocrlf true &&
@@ -126,7 +126,7 @@ test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '
LFonlydiff=$(git diff LFonly) &&
CRLFonlydiff=$(git diff CRLFonly) &&
LFwithNULdiff=$(git diff LFwithNUL) &&
- test -z "$LFonlydiff" -a -n "$CRLFonlydiff" -a -z "$LFwithNULdiff"
+ test -z "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index 5f6208a..e2be985 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -175,8 +175,8 @@ attr_ascii () {
text,lf) echo "text eol=lf" ;;
text,crlf) echo "text eol=crlf" ;;
auto,) echo "text=auto" ;;
- auto,lf) echo "text eol=lf" ;;
- auto,crlf) echo "text eol=crlf" ;;
+ auto,lf) echo "text=auto eol=lf" ;;
+ auto,crlf) echo "text=auto eol=crlf" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
@@ -397,10 +397,9 @@ commit_chk_wrnNNO "" "" false "" "" "" ""
commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
commit_chk_wrnNNO "" "" input "" "" "" "" ""
-commit_chk_wrnNNO "auto" "" false "$WILC" "$WICL" "$WAMIX" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" LF_CRLF "" ""
-commit_chk_wrnNNO "auto" "" input "" CRLF_LF CRLF_LF "" ""
-
+commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
+commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
@@ -408,8 +407,8 @@ do
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
done
@@ -454,9 +453,9 @@ do
check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto "" $crlf LF LF LF LF_mix_CR CRLF_nul
- check_in_repo_NNO auto lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO auto crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
@@ -493,7 +492,8 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-for id in "" ident
+#for id in "" ident
+for id in ""
do
for ceol in lf crlf native
do
@@ -509,7 +509,7 @@ do
checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
@@ -517,7 +517,7 @@ do
# core.autocrlf true
checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
@@ -531,8 +531,8 @@ do
checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 85c10b0..33b77ee 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -16,6 +16,13 @@ test_description='CRLF merge conflict across text=auto change
test_have_prereq SED_STRIPS_CR && SED_OPTIONS=-b
+compare_files () {
+ tr '\015\000' QN <"$1" >"$1".expect &&
+ tr '\015\000' QN <"$2" >"$2".actual &&
+ test_cmp "$1".expect "$2".actual &&
+ rm "$1".expect "$2".actual
+}
+
test_expect_success setup '
git config core.autocrlf false &&
@@ -30,7 +37,7 @@ test_expect_success setup '
git branch side &&
echo "* text=auto" >.gitattributes &&
- touch file &&
+ echo first line >file &&
git add .gitattributes file &&
test_tick &&
git commit -m "normalize file" &&
@@ -81,7 +88,7 @@ test_expect_success 'Merge after setting text=auto' '
rm -f .gitattributes &&
git reset --hard a &&
git merge b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Merge addition of text=auto' '
@@ -99,7 +106,7 @@ test_expect_success 'Merge addition of text=auto' '
rm -f .gitattributes &&
git reset --hard b &&
git merge a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
@@ -121,7 +128,7 @@ test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
git reset --hard a &&
test_must_fail git merge b &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
@@ -143,7 +150,7 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
git reset --hard b &&
test_must_fail git merge a &&
fuzz_conflict file >file.fuzzy &&
- test_cmp expected file.fuzzy
+ compare_files expected file.fuzzy
'
test_expect_failure 'checkout -m after setting text=auto' '
@@ -158,7 +165,7 @@ test_expect_failure 'checkout -m after setting text=auto' '
git reset --hard initial &&
git checkout a -- . &&
git checkout -m b &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'checkout -m addition of text=auto' '
@@ -173,7 +180,7 @@ test_expect_failure 'checkout -m addition of text=auto' '
git reset --hard initial &&
git checkout b -- . &&
git checkout -m a &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_failure 'cherry-pick patch from after text=auto was added' '
@@ -187,7 +194,7 @@ test_expect_failure 'cherry-pick patch from after text=auto was added' '
git reset --hard b &&
test_must_fail git cherry-pick a >err 2>&1 &&
grep "[Nn]othing added" err &&
- test_cmp expected file
+ compare_files expected file
'
test_expect_success 'Test delete/normalize conflict' '
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v9 4/6] convert.c: more safer crlf handling with text attribute
2016-03-07 22:34 ` Junio C Hamano
` (62 preceding siblings ...)
2016-05-07 6:11 ` [PATCH v9 3/6] convert: unify the "auto" handling of CRLF tboegi
@ 2016-05-07 6:11 ` tboegi
2016-05-07 6:11 ` [PATCH v9 5/6] t6038; use crlf on all platforms tboegi
2016-05-07 6:11 ` [PATCH v9 6/6] convert: ce_compare_data() checks for a sha1 of a path tboegi
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-05-07 6:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
A follow-up after a discussion how to fix the flaky execution
of t0025, gmane/$284352.
This patch extends the work done in commit c480539:
"Make it work also for un-normalized repositories". Make sure that CRLF
can be converted round trip, or don't convert them at all.
The old handling would treat a file as unchanged after checkout,
as long as it is not touched in the work tree and mtime matches the value
recorded in the index.
When the mtime is changed in the working tree, or the inode is changed,
the file is reported as modified.
The following sequence is now handled reproducable:
$ git init
$ printf "line1\r\n" >file.bat
$ git add file.bat
$ git commit -m "Add file with CRLF" file.bat
$ echo "*.bat text eol=crlf" >.gitattributes
$ git commit -m "bat files should have CRLF"
$ git status
# nothing to commit, working directory clean
$ git push <upstream>
$ printf "newline\r\n" >>file.bat
$ mv file.bat file.sav
$ git checkout file.bat
$ git status
#modified: file.bat
The new handling makes sure that after running "git reset --hard".
"git status" reports the working tree as clean regarding CRLF conversion.
It makes sure that the Git-internal eol conversion is
doing roundtrip. A user can still write an external smudge/clean filter
outside Git, which doesn't do a roundtrip and the working directory is
not clean.
The functionality of has_cr_in_index() is turned into has_crlf_in_index(),
and the function is integrated into would_convert_crlf_at_commit().
Check for CRLF in the index instead of CR, the bit CONVERT_STAT_BITS_ANY_CR
is no longer used and removed, as well as "lonecr" in struct text_stat.
Rewrite check_safe_crlf() in convert.c to simulate checkin-checkout,
to detect whether any line endings are converted.
Add a warning, similar to the CRLF-LF replacement, when a file is commited,
and after the next checkout the line endings are not they should be.
Modify the lf_to_crlf_filter:
Files with LF are converted into CRLF, file with CRLF are not changed.
Files with mixed line endings are not converted, the filter fails, and Git
falls back to the non-streaming handling, see write_entry().
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/gitattributes.txt | 19 ++--
convert.c | 233 +++++++++++++++++++++++++---------------
t/t0025-crlf-auto.sh | 8 +-
t/t0027-auto-crlf.sh | 92 ++++++++--------
4 files changed, 212 insertions(+), 140 deletions(-)
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index d7a124b..836461d 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -110,7 +110,7 @@ repository upon 'git add' and 'git commit'.
`text`
^^^^^^
-This attribute enables and controls end-of-line normalization. When a
+This attribute enables and controls end-of-line conversion. 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
@@ -120,8 +120,11 @@ Note that `core.autocrlf` overrides `core.eol`
Set::
Setting the `text` attribute on a path enables end-of-line
- normalization and marks the path as a text file. End-of-line
+ conversion and marks the path as a text file. End-of-line
conversion takes place without guessing the content type.
+ Files that have been commited with CRLF before the text attribute
+ is set and commited are not normalized. No end-of-line conversion
+ is done at checkout or checkin.
Unset::
@@ -131,9 +134,9 @@ Unset::
Set to string value "auto"::
When `text` is set to "auto", the path is marked for automatic
- end-of-line conversion. If Git decides that the content is
- text, its line endings are converted to LF on checkin.
- When the file has been commited with CRLF, no conversion is done.
+ end-of-line normalization. If Git decides that the content is
+ text, and the path has no CRLF in the index,
+ its line endings are converted to LF on checkin.
Unspecified::
@@ -148,8 +151,10 @@ unspecified.
^^^^^
This attribute sets a specific line-ending style to be used in the
-working directory. It enables end-of-line conversion without any
-content checks, effectively setting the `text` attribute.
+working directory. It sets the `text` attribute, unless `text=auto`
+is specified.
+When the file had been commited with CRLF in the index, no conversion
+is done at checkout or commit.
Set to string value "crlf"::
diff --git a/convert.c b/convert.c
index 3782172..8d4c42a 100644
--- a/convert.c
+++ b/convert.c
@@ -17,7 +17,8 @@
#define CONVERT_STAT_BITS_TXT_LF 0x1
#define CONVERT_STAT_BITS_TXT_CRLF 0x2
#define CONVERT_STAT_BITS_BIN 0x4
-#define CONVERT_STAT_BITS_ANY_CR 0x8
+
+#define CONVERT_STAT_BITS_MIXED (CONVERT_STAT_BITS_TXT_LF | CONVERT_STAT_BITS_TXT_CRLF)
enum crlf_action {
CRLF_UNDEFINED,
@@ -32,7 +33,7 @@ enum crlf_action {
struct text_stat {
/* NUL, CR, LF and CRLF counts */
- unsigned stat_bits, lonecr, lonelf, crlf;
+ unsigned stat_bits, lonelf;
/* These are just approximations! */
unsigned printable, nonprintable;
@@ -48,13 +49,10 @@ static void do_gather_stats(const char *buf, unsigned long size,
for (i = 0; i < size; i++) {
unsigned char c = buf[i];
if (c == '\r') {
- stats->stat_bits |= CONVERT_STAT_BITS_ANY_CR;
if (i+1 < size && buf[i+1] == '\n') {
- stats->crlf++;
i++;
stats->stat_bits |= CONVERT_STAT_BITS_TXT_CRLF;
} else {
- stats->lonecr++;
stats->stat_bits |= CONVERT_STAT_BITS_BIN;
}
continue;
@@ -135,7 +133,7 @@ static unsigned get_convert_stats_sha1(unsigned const char *sha1,
if (!readlen)
break;
do_gather_stats(buf, (unsigned long)readlen, &stats, earlyout);
- if (stats.stat_bits & earlyout)
+ if ((stats.stat_bits & earlyout) == earlyout)
break; /* We found what we have been searching for */
}
close_and_exit_i:
@@ -146,11 +144,9 @@ close_and_exit_i:
static const char *convert_stats_ascii(unsigned convert_stats)
{
- unsigned mask = CONVERT_STAT_BITS_TXT_LF |
- CONVERT_STAT_BITS_TXT_CRLF;
if (convert_stats & CONVERT_STAT_BITS_BIN)
return "-text";
- switch (convert_stats & mask) {
+ switch (convert_stats) {
case CONVERT_STAT_BITS_TXT_LF:
return "lf";
case CONVERT_STAT_BITS_TXT_CRLF:
@@ -162,7 +158,16 @@ static const char *convert_stats_ascii(unsigned convert_stats)
}
}
-static unsigned get_convert_stats_wt(const char *path)
+const char *get_cached_convert_stats_ascii(const char *path)
+{
+ unsigned convert_stats;
+ unsigned earlyout = CONVERT_STAT_BITS_BIN;
+ convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
+ earlyout);
+ return convert_stats_ascii(convert_stats);
+}
+
+const char *get_wt_convert_stats_ascii(const char *path)
{
struct text_stat stats;
unsigned earlyout = CONVERT_STAT_BITS_BIN;
@@ -184,23 +189,7 @@ static unsigned get_convert_stats_wt(const char *path)
}
close(fd);
convert_nonprintable(&stats);
- return stats.stat_bits;
-}
-
-const char *get_cached_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- unsigned earlyout = CONVERT_STAT_BITS_BIN;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- earlyout);
- return convert_stats_ascii(convert_stats);
-}
-
-const char *get_wt_convert_stats_ascii(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_wt(path);
- return convert_stats_ascii(convert_stats);
+ return convert_stats_ascii(stats.stat_bits);
}
static int text_eol_is_crlf(void)
@@ -239,43 +228,95 @@ static enum eol output_eol(enum crlf_action crlf_action)
return core_eol;
}
+static int would_convert_lf_at_checkout(unsigned convert_stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ if (output_eol(crlf_action) != EOL_CRLF)
+ return 0;
+
+ /* No "naked" LF? Nothing to convert, regardless. */
+ if (!convert_stats & CONVERT_STAT_BITS_TXT_LF)
+ return 0;
+
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ /* auto: binary files are not converted */
+ if (convert_stats & CONVERT_STAT_BITS_BIN)
+ return 0;
+ }
+ /* If we have any CRLF line endings, we do not touch it */
+ /* This is the new safer autocrlf-handling */
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+
+}
+
+static int would_convert_crlf_at_commit(const char * path,
+ const struct text_stat *stats,
+ size_t len,
+ enum crlf_action crlf_action)
+{
+ unsigned stat_bits_index;
+ /* No CRLF? Nothing to convert, regardless. */
+ if (!(stats->stat_bits & CONVERT_STAT_BITS_TXT_CRLF))
+ return 0;
+ /*
+ * If the file in the index has any CRLF in it, do not convert.
+ * This is the new safer autocrlf handling.
+ */
+ stat_bits_index = get_convert_stats_sha1(get_sha1_from_cache(path),
+ CONVERT_STAT_BITS_TXT_CRLF);
+ if (stat_bits_index & CONVERT_STAT_BITS_TXT_CRLF)
+ return 0;
+ return 1;
+}
+
static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
- struct text_stat *stats, enum safe_crlf checksafe)
+ enum safe_crlf checksafe,
+ unsigned convert_stats, unsigned new_convert_stats)
{
+ enum eol new_eol = output_eol(crlf_action);
+ const char *err_warn_msg = NULL;
if (!checksafe)
return;
-
- if (output_eol(crlf_action) == EOL_LF) {
+ if (convert_stats & CONVERT_STAT_BITS_TXT_CRLF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
/*
* 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.\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 (output_eol(crlf_action) == EOL_CRLF) {
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if (convert_stats & CONVERT_STAT_BITS_TXT_LF &&
+ !(new_convert_stats & CONVERT_STAT_BITS_TXT_LF)) {
/*
* CRLFs would be added by checkout:
* check if we have "naked" LFs
*/
- if (stats->lonelf) {
- if (checksafe == SAFE_CRLF_WARN)
- 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);
- }
+ if (checksafe == SAFE_CRLF_WARN)
+ 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);
+ }
+ if ((new_convert_stats & CONVERT_STAT_BITS_MIXED) == CONVERT_STAT_BITS_MIXED)
+ err_warn_msg = "mixed eol";
+ else if (new_eol == EOL_LF && new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)
+ err_warn_msg = "CRLF";
+
+ if (err_warn_msg) {
+ if (checksafe == SAFE_CRLF_WARN)
+ warning("%s will be present after commit and checkout in %s.",
+ err_warn_msg, path);
+ else
+ die("%s will be present after commit and checkout in %s",
+ err_warn_msg, path);
}
-}
-
-static int has_cr_in_index(const char *path)
-{
- unsigned convert_stats;
- convert_stats = get_convert_stats_sha1(get_sha1_from_cache(path),
- CONVERT_STAT_BITS_ANY_CR);
- return convert_stats & CONVERT_STAT_BITS_ANY_CR;
}
static int crlf_to_git(const char *path, const char *src, size_t len,
@@ -284,7 +325,7 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
{
struct text_stat stats;
char *dst;
-
+ int convert_crlf;
if (crlf_action == CRLF_BINARY ||
(src && !len))
return 0;
@@ -296,24 +337,42 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (!buf && !src)
return 1;
- gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
-
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
+ gather_stats(src, len, &stats, CONVERT_STAT_BITS_BIN);
if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
return 0;
- /*
- * If the file in the index has any CR in it, do not convert.
- * This is the new safer autocrlf handling.
- */
- if (checksafe == SAFE_CRLF_RENORMALIZE)
- checksafe = SAFE_CRLF_FALSE;
- else if (has_cr_in_index(path))
- return 0;
+ } else {
+ gather_stats(src, len, &stats, 0);
+ }
+ if (checksafe == SAFE_CRLF_RENORMALIZE) {
+ convert_crlf = 1;
+ checksafe = SAFE_CRLF_FALSE;
+ } else {
+ convert_crlf = would_convert_crlf_at_commit(path, &stats, len,
+ crlf_action);
}
- check_safe_crlf(path, crlf_action, &stats, checksafe);
- /* Optimization: No CRLF? Nothing to convert, regardless. */
- if (!stats.crlf)
+ if (checksafe) {
+ unsigned convert_stats = stats.stat_bits;
+ unsigned new_convert_stats = convert_stats;
+ /* Simulate commit */
+ if (convert_crlf &&
+ (new_convert_stats & CONVERT_STAT_BITS_TXT_CRLF)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_LF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_CRLF;
+ }
+ /* Simulate checkout */
+ if (would_convert_lf_at_checkout(new_convert_stats,
+ len, crlf_action)) {
+ new_convert_stats |= CONVERT_STAT_BITS_TXT_CRLF;
+ new_convert_stats &= ~CONVERT_STAT_BITS_TXT_LF;
+ }
+ check_safe_crlf(path, crlf_action, checksafe,
+ convert_stats, new_convert_stats);
+ }
+ if (!convert_crlf)
return 0;
/*
@@ -327,7 +386,9 @@ 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 (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
+ if (crlf_action == CRLF_AUTO ||
+ crlf_action == CRLF_AUTO_INPUT ||
+ crlf_action == CRLF_AUTO_CRLF) {
/*
* If we guessed, we already know we rejected a file with
* lone CR, and we can strip a CR without looking at what
@@ -354,28 +415,15 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
{
char *to_free = NULL;
struct text_stat stats;
- unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
-
-
- if (!len || output_eol(crlf_action) != EOL_CRLF)
+ unsigned earlyout = 0; /* Need to count lonelf */
+ if (!len)
return 0;
gather_stats(src, len, &stats, earlyout);
-
- /* No "naked" LF? Nothing to convert, regardless. */
- if (!stats.lonelf)
+ if (!would_convert_lf_at_checkout(stats.stat_bits,
+ len, crlf_action))
return 0;
- if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
- /* If we have any CR or CRLF line endings, we do not touch it */
- /* This is the new safer autocrlf-handling */
- if (stats.lonecr || stats.crlf )
- return 0;
-
- if (stats.stat_bits & CONVERT_STAT_BITS_BIN)
- return 0;
- }
-
/* are we "faking" in place editing ? */
if (src == buf->buf)
to_free = strbuf_detach(buf, NULL);
@@ -1067,6 +1115,8 @@ int is_null_stream_filter(struct stream_filter *filter)
struct lf_to_crlf_filter {
struct stream_filter filter;
unsigned has_held:1;
+ unsigned expanded_loneLF:1;
+ unsigned had_CRLF:1;
char held;
};
@@ -1107,7 +1157,12 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
char ch = input[i];
if (ch == '\n') {
- output[o++] = '\r';
+ if (!lf_to_crlf->had_CRLF) {
+ output[o++] = '\r';
+ lf_to_crlf->expanded_loneLF = 1;
+ }
+ if (was_cr)
+ lf_to_crlf->had_CRLF = 1;
} else if (was_cr) {
/*
* Previous round saw CR and it is not followed
@@ -1136,6 +1191,14 @@ static int lf_to_crlf_filter_fn(struct stream_filter *filter,
was_cr = 0;
output[o++] = ch;
+ if (lf_to_crlf->expanded_loneLF &&
+ lf_to_crlf->had_CRLF) {
+ /*
+ * Mixed EOL, round trip not possible.
+ */
+ return 1;
+ }
+
}
*osize_p -= o;
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index d0bee08..b5f93e2 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 "$LFonlydiff" -a -z "$CRLFonlydiff" -a -z "$LFwithNULdiff"
'
-test_expect_success 'crlf=true causes a CRLF file to be normalized' '
+test_expect_success 'crlf=true causes a CRLF file not to be normalized' '
# Backwards compatibility check
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
@@ -49,10 +49,10 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
-test_expect_success 'text=true causes a CRLF file to be normalized' '
+test_expect_success 'text=true causes a CRLF file not to be normalized' '
rm -f .gitattributes tmp LFonly CRLFonly LFwithNUL &&
echo "CRLFonly text" > .gitattributes &&
@@ -61,7 +61,7 @@ test_expect_success 'text=true causes a CRLF file to be normalized' '
# Note, "normalized" means that git will normalize it if added
has_cr CRLFonly &&
CRLFonlydiff=$(git diff CRLFonly) &&
- test -n "$CRLFonlydiff"
+ test -z "$CRLFonlydiff"
'
test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '
diff --git a/t/t0027-auto-crlf.sh b/t/t0027-auto-crlf.sh
index e2be985..1f08912 100755
--- a/t/t0027-auto-crlf.sh
+++ b/t/t0027-auto-crlf.sh
@@ -71,10 +71,14 @@ check_warning () {
case "$1" in
LF_CRLF) echo "warning: LF will be replaced by CRLF" >"$2".expect ;;
CRLF_LF) echo "warning: CRLF will be replaced by LF" >"$2".expect ;;
+ CRLF) echo "warning: CRLF will be present after commit and checkout" >"$2".expect ;;
+ mixed) echo "warning: mixed eol will be present after commit and checkout" >"$2".expect ;;
'') >"$2".expect ;;
*) echo >&2 "Illegal 1": "$1" ; return false ;;
esac
- grep "will be replaced by" "$2" | sed -e "s/\(.*\) in [^ ]*$/\1/" | uniq >"$2".actual
+ egrep "will be replaced by|will be present after commit" "$2" |
+ sed -e "s/\(.*\) in [^ ]*$/\1/" |
+ uniq >"$2".actual
test_cmp "$2".expect "$2".actual
}
@@ -169,7 +173,7 @@ stats_ascii () {
# Take none (=empty), one or two args
# convert.c: eol=XX overrides text=auto
attr_ascii () {
- case $1,$2 in
+ case "$1","$2" in
-text,*) echo "-text" ;;
text,) echo "text" ;;
text,lf) echo "text eol=lf" ;;
@@ -349,10 +353,12 @@ then
WILC=LF_CRLF
WICL=
WAMIX=LF_CRLF
+ Pcrlf=
else
WILC=
WICL=CRLF_LF
WAMIX=CRLF_LF
+ Pcrlf=CRLF
fi
# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
@@ -392,31 +398,32 @@ test_expect_success 'commit files attr=crlf' '
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
'
-# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
+# attr aeol ceol LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
commit_chk_wrnNNO "" "" false "" "" "" "" ""
-commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "" "" input "" "" "" "" ""
+commit_chk_wrnNNO "" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "" "" input "" CRLF mixed "" ""
+
+commit_chk_wrnNNO "auto" "" false "$WILC" "$Pcrlf" mixed "" ""
+commit_chk_wrnNNO "auto" "" true LF_CRLF "" mixed "" ""
+commit_chk_wrnNNO "auto" "" input "" CRLF mixed "" ""
+commit_chk_wrnNNO "text" "" false "$WILC" "$Pcrlf" mixed "$WILC" "$Pcrlf"
+commit_chk_wrnNNO "text" "" true LF_CRLF "" mixed LF_CRLF ""
+commit_chk_wrnNNO "text" "" input "" CRLF mixed "" CRLF
+
-commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
-commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
-commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
for crlf in true false input
do
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
- commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
- commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
- commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
- commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
- commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
+ commit_chk_wrnNNO "" lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" mixed LF_CRLF ""
+ commit_chk_wrnNNO auto lf $crlf "" CRLF mixed "" ""
+ commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" mixed "" ""
+ commit_chk_wrnNNO text lf $crlf "" CRLF mixed "" CRLF
+ commit_chk_wrnNNO text crlf $crlf LF_CRLF "" mixed LF_CRLF ""
done
-commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
-commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
-commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
-
test_expect_success 'create files cleanup' '
rm -f *.txt &&
git -c core.autocrlf=false reset --hard
@@ -456,9 +463,9 @@ do
check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
- check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
- check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
+ check_in_repo_NNO text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
+ check_in_repo_NNO text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
done
################################################################################
# Check how files in the repo are changed when they are checked out
@@ -479,12 +486,10 @@ done
if test_have_prereq NATIVE_CRLF
then
-MIX_CRLF_LF=CRLF
MIX_LF_CR=CRLF_mix_CR
NL=CRLF
LFNUL=CRLF_nul
else
-MIX_CRLF_LF=CRLF_mix_LF
MIX_LF_CR=LF_mix_CR
NL=LF
LFNUL=LF_nul
@@ -492,8 +497,7 @@ fi
export CRLF_MIX_LF_CR MIX NL
# Same handling with and without ident
-#for id in "" ident
-for id in ""
+for id in "" ident
do
for ceol in lf crlf native
do
@@ -501,38 +505,38 @@ do
do
# -text overrides core.autocrlf and core.eol
# text and eol=crlf or eol=lf override core.autocrlf and core.eol
- checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "-text" "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text
- checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# currently the same as text, eol=XXX
- checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# core.autocrlf false, different core.eol
- checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# core.autocrlf true
- checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf = true overrides core.eol
- checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
+ checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
# text: core.autocrlf = input overrides core.eol
- checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text=auto + eol=XXX
done
# text: core.autocrlf=false uses core.eol
- checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
- checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files text "$id" "" false crlf CRLF CRLF CRLF_mix_LF CRLF_mix_CR CRLF_nul
+ checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
- checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
+ checkout_files text "$id" "" false "" $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
+ checkout_files text "$id" "" false native $NL CRLF CRLF_mix_LF "$MIX_LF_CR" "$LFNUL"
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
- checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
- checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
+ checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
done
# Should be the last test case: remove some files from the worktree
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v9 5/6] t6038; use crlf on all platforms
2016-03-07 22:34 ` Junio C Hamano
` (63 preceding siblings ...)
2016-05-07 6:11 ` [PATCH v9 4/6] convert.c: more safer crlf handling with text attribute tboegi
@ 2016-05-07 6:11 ` tboegi
2016-05-07 6:11 ` [PATCH v9 6/6] convert: ce_compare_data() checks for a sha1 of a path tboegi
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-05-07 6:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
t6038 uses different code, dependig if NATIVE_CRLF is set ot not.
When the native line endings are LF, merge.renormalize is not tested very well.
Change the test to always use CRLF by setting core.eol=crlf.
After doing so, the test fails:
rm '.gitattributes'
rm 'control_file'
rm 'file'
rm 'inert_file'
HEAD is now at 0d9ffb6 add line from b
error: addinfo_cache failed for path 'file'
file: unmerged (cbd69ec7cd12dd0989e853923867d94c8519aa52)
file: unmerged (ad55e240aeb42e0d9a0e18d6d8b02dd82ee3e527)
file: unmerged (99b633103c15c20cebebf821133ab526b0ff90b2)
fatal: git write-tree failed to write a tree
Merging:
0d9ffb6 add line from b
virtual a
found 1 common ancestor:
1c56df1 Initial
Auto-merging file
not ok 4 - Merge addition of text=auto
This will be addressed in the next commit.
---
t/t6038-merge-text-auto.sh | 37 +++++++++++--------------------------
1 file changed, 11 insertions(+), 26 deletions(-)
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 33b77ee..0108ead 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -25,6 +25,7 @@ compare_files () {
test_expect_success setup '
git config core.autocrlf false &&
+ git config core.eol crlf &&
echo first line | append_cr >file &&
echo first line >control_file &&
@@ -79,10 +80,8 @@ test_expect_success 'Merge after setting text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -97,10 +96,8 @@ test_expect_success 'Merge addition of text=auto' '
same line
EOF
- if test_have_prereq NATIVE_CRLF; then
- append_cr <expected >expected.temp &&
- mv expected.temp expected
- fi &&
+ append_cr <expected >expected.temp &&
+ mv expected.temp expected &&
git config merge.renormalize true &&
git rm -fr . &&
rm -f .gitattributes &&
@@ -111,15 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected
- else
- echo first line >>expected &&
- echo same line >>expected &&
- echo ======= >>expected
- fi &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
+ echo ======= | append_cr >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -135,15 +126,9 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- if test_have_prereq NATIVE_CRLF; then
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected
- else
- echo ======= >>expected &&
- echo first line >>expected &&
- echo same line >>expected
- fi &&
+ echo ======= | append_cr >>expected &&
+ echo first line | append_cr >>expected &&
+ echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* [PATCH v9 6/6] convert: ce_compare_data() checks for a sha1 of a path
2016-03-07 22:34 ` Junio C Hamano
` (64 preceding siblings ...)
2016-05-07 6:11 ` [PATCH v9 5/6] t6038; use crlf on all platforms tboegi
@ 2016-05-07 6:11 ` tboegi
65 siblings, 0 replies; 126+ messages in thread
From: tboegi @ 2016-05-07 6:11 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
To compare a file in working tree with the index, convert_to_git() is used,
the the result is hashed and the hash value compared with ce->sha1.
Deep down would_convert_crlf_at_commit() is invoked, to check if CRLF
are converted or not: When a CRLF had been in the index before, CRLF in
the working tree are not converted.
While in a merge, a file name in the working tree has different blobs
in the index with different hash values.
Forwarding ce->sha1 from ce_compare_data() into crlf_to_git() makes sure
the would_convert_crlf_at_commit() looks at the appropriate blob.
---
cache.h | 1 +
convert.c | 30 ++++++++++++++++++++----------
convert.h | 23 +++++++++++++++++++----
read-cache.c | 4 +++-
sha1_file.c | 17 +++++++++++++----
t/t6038-merge-text-auto.sh | 12 ++++++------
6 files changed, 62 insertions(+), 25 deletions(-)
diff --git a/cache.h b/cache.h
index 28f23d7..43a4fd6 100644
--- a/cache.h
+++ b/cache.h
@@ -605,6 +605,7 @@ extern int ie_modified(const struct index_state *, const struct cache_entry *, s
#define HASH_WRITE_OBJECT 1
#define HASH_FORMAT_CHECK 2
+#define HASH_CE_HAS_SHA1 4
extern int index_fd(unsigned char *sha1, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);
extern int index_path(unsigned char *sha1, const char *path, struct stat *st, unsigned flags);
diff --git a/convert.c b/convert.c
index 8d4c42a..ccbd2e9 100644
--- a/convert.c
+++ b/convert.c
@@ -254,9 +254,8 @@ static int would_convert_lf_at_checkout(unsigned convert_stats,
}
-static int would_convert_crlf_at_commit(const char * path,
+static int would_convert_crlf_at_commit(const unsigned char *sha1,
const struct text_stat *stats,
- size_t len,
enum crlf_action crlf_action)
{
unsigned stat_bits_index;
@@ -267,7 +266,7 @@ static int would_convert_crlf_at_commit(const char * path,
* If the file in the index has any CRLF in it, do not convert.
* This is the new safer autocrlf handling.
*/
- stat_bits_index = get_convert_stats_sha1(get_sha1_from_cache(path),
+ stat_bits_index = get_convert_stats_sha1(sha1,
CONVERT_STAT_BITS_TXT_CRLF);
if (stat_bits_index & CONVERT_STAT_BITS_TXT_CRLF)
return 0;
@@ -319,7 +318,8 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
}
}
-static int crlf_to_git(const char *path, const char *src, size_t len,
+static int crlf_to_git(const char *path, const unsigned char *sha1,
+ const char *src, size_t len,
struct strbuf *buf,
enum crlf_action crlf_action, enum safe_crlf checksafe)
{
@@ -350,7 +350,14 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
convert_crlf = 1;
checksafe = SAFE_CRLF_FALSE;
} else {
- convert_crlf = would_convert_crlf_at_commit(path, &stats, len,
+ /*
+ * If ce_compare_data() wants to check a specic blob,
+ * then sha1 != NULL and should be used
+ */
+ if (!sha1)
+ sha1 = get_sha1_from_cache(path);
+
+ convert_crlf = would_convert_crlf_at_commit(sha1, &stats,
crlf_action);
}
@@ -949,8 +956,9 @@ const char *get_convert_attr_ascii(const char *path)
return "";
}
-int convert_to_git(const char *path, const char *src, size_t len,
- struct strbuf *dst, enum safe_crlf checksafe)
+int convert_to_git_ce_sha1(const char *path, const unsigned char *sha1,
+ const char *src, size_t len,
+ struct strbuf *dst, enum safe_crlf checksafe)
{
int ret = 0;
const char *filter = NULL;
@@ -971,7 +979,7 @@ 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, ca.crlf_action, checksafe);
+ ret |= crlf_to_git(path, sha1, src, len, dst, ca.crlf_action, checksafe);
if (ret && dst) {
src = dst->buf;
len = dst->len;
@@ -979,7 +987,9 @@ int convert_to_git(const char *path, const char *src, size_t len,
return ret | ident_to_git(path, src, len, dst, ca.ident);
}
-void convert_to_git_filter_fd(const char *path, int fd, struct strbuf *dst,
+void convert_to_git_filter_fd(const char *path,
+ const unsigned char *sha1,
+ int fd, struct strbuf *dst,
enum safe_crlf checksafe)
{
struct conv_attrs ca;
@@ -991,7 +1001,7 @@ void convert_to_git_filter_fd(const char *path, int fd, struct strbuf *dst,
if (!apply_filter(path, NULL, 0, fd, dst, ca.drv->clean))
die("%s: clean filter '%s' failed", path, ca.drv->name);
- crlf_to_git(path, dst->buf, dst->len, dst, ca.crlf_action, checksafe);
+ crlf_to_git(path, sha1, dst->buf, dst->len, dst, ca.crlf_action, checksafe);
ident_to_git(path, dst->buf, dst->len, dst, ca.ident);
}
diff --git a/convert.h b/convert.h
index 81b6cdf..769e9c9 100644
--- a/convert.h
+++ b/convert.h
@@ -38,8 +38,16 @@ extern const char *get_wt_convert_stats_ascii(const char *path);
extern const char *get_convert_attr_ascii(const char *path);
/* returns 1 if *dst was used */
-extern int convert_to_git(const char *path, const char *src, size_t len,
- struct strbuf *dst, enum safe_crlf checksafe);
+extern int convert_to_git_ce_sha1(const char *path, const unsigned char *sha1,
+ const char *src, size_t len,
+ struct strbuf *dst, enum safe_crlf checksafe);
+
+static inline int convert_to_git(const char *path, const char *src, size_t len,
+ struct strbuf *dst, enum safe_crlf checksafe)
+{
+ return convert_to_git_ce_sha1(path, NULL, src, len, dst, checksafe);
+}
+
extern int convert_to_working_tree(const char *path, const char *src,
size_t len, struct strbuf *dst);
extern int renormalize_buffer(const char *path, const char *src, size_t len,
@@ -48,9 +56,16 @@ static inline int would_convert_to_git(const char *path)
{
return convert_to_git(path, NULL, 0, NULL, 0);
}
+static inline int would_convert_to_git_ce_sha1(const char *path,
+ const unsigned char *sha1)
+{
+ return convert_to_git_ce_sha1(path, sha1, NULL, 0, NULL, 0);
+}
+
/* Precondition: would_convert_to_git_filter_fd(path) == true */
-extern void convert_to_git_filter_fd(const char *path, int fd,
- struct strbuf *dst,
+extern void convert_to_git_filter_fd(const char *path,
+ const unsigned char *sha1,
+ int fd, struct strbuf *dst,
enum safe_crlf checksafe);
extern int would_convert_to_git_filter_fd(const char *path);
diff --git a/read-cache.c b/read-cache.c
index a3ef967..0ebc237 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -163,7 +163,9 @@ static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
if (fd >= 0) {
unsigned char sha1[20];
- if (!index_fd(sha1, fd, st, OBJ_BLOB, ce->name, 0))
+ unsigned flags = HASH_CE_HAS_SHA1;
+ memcpy(sha1, ce->sha1, sizeof(sha1));
+ if (!index_fd(sha1, fd, st, OBJ_BLOB, ce->name, flags))
match = hashcmp(sha1, ce->sha1);
/* index_fd() closed the file descriptor already */
}
diff --git a/sha1_file.c b/sha1_file.c
index d0f2aa0..dd013d5 100644
--- a/sha1_file.c
+++ b/sha1_file.c
@@ -3275,6 +3275,7 @@ static int index_mem(unsigned char *sha1, void *buf, size_t size,
{
int ret, re_allocated = 0;
int write_object = flags & HASH_WRITE_OBJECT;
+ const int valid_sha1 = flags & HASH_CE_HAS_SHA1;
if (!type)
type = OBJ_BLOB;
@@ -3284,8 +3285,11 @@ static int index_mem(unsigned char *sha1, void *buf, size_t size,
*/
if ((type == OBJ_BLOB) && path) {
struct strbuf nbuf = STRBUF_INIT;
- if (convert_to_git(path, buf, size, &nbuf,
- write_object ? safe_crlf : SAFE_CRLF_FALSE)) {
+ if (convert_to_git_ce_sha1(path,
+ valid_sha1 ? sha1 : NULL,
+ buf, size, &nbuf,
+ write_object ? safe_crlf : SAFE_CRLF_FALSE)){
+
buf = strbuf_detach(&nbuf, &size);
re_allocated = 1;
}
@@ -3313,12 +3317,15 @@ static int index_stream_convert_blob(unsigned char *sha1, int fd,
{
int ret;
const int write_object = flags & HASH_WRITE_OBJECT;
+ const int valid_sha1 = flags & HASH_CE_HAS_SHA1;
struct strbuf sbuf = STRBUF_INIT;
assert(path);
assert(would_convert_to_git_filter_fd(path));
- convert_to_git_filter_fd(path, fd, &sbuf,
+ convert_to_git_filter_fd(path,
+ valid_sha1 ? sha1 : NULL,
+ fd, &sbuf,
write_object ? safe_crlf : SAFE_CRLF_FALSE);
if (write_object)
@@ -3396,6 +3403,8 @@ int index_fd(unsigned char *sha1, int fd, struct stat *st,
enum object_type type, const char *path, unsigned flags)
{
int ret;
+ const unsigned char *sha1_ce;
+ sha1_ce = flags & HASH_CE_HAS_SHA1 ? sha1 : NULL;
/*
* Call xsize_t() only when needed to avoid potentially unnecessary
@@ -3406,7 +3415,7 @@ int index_fd(unsigned char *sha1, int fd, struct stat *st,
else if (!S_ISREG(st->st_mode))
ret = index_pipe(sha1, fd, type, path, flags);
else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||
- (path && would_convert_to_git(path)))
+ (path && would_convert_to_git_ce_sha1(path,sha1_ce)))
ret = index_core(sha1, fd, xsize_t(st->st_size), type, path,
flags);
else
diff --git a/t/t6038-merge-text-auto.sh b/t/t6038-merge-text-auto.sh
index 0108ead..5450cba 100755
--- a/t/t6038-merge-text-auto.sh
+++ b/t/t6038-merge-text-auto.sh
@@ -108,9 +108,9 @@ test_expect_success 'Merge addition of text=auto' '
test_expect_success 'Detect CRLF/LF conflict after setting text=auto' '
echo "<<<<<<<" >expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
+ echo ======= >>expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
echo ">>>>>>>" >>expected &&
@@ -126,9 +126,9 @@ test_expect_success 'Detect LF/CRLF conflict from addition of text=auto' '
echo "<<<<<<<" >expected &&
echo first line | append_cr >>expected &&
echo same line | append_cr >>expected &&
- echo ======= | append_cr >>expected &&
- echo first line | append_cr >>expected &&
- echo same line | append_cr >>expected &&
+ echo ======= >>expected &&
+ echo first line >>expected &&
+ echo same line >>expected &&
echo ">>>>>>>" >>expected &&
git config merge.renormalize false &&
rm -f .gitattributes &&
--
2.0.0.rc1.6318.g0c2c796
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH v9 1/6] read-cache: factor out get_sha1_from_index() helper
2016-05-07 6:10 ` [PATCH v9 1/6] read-cache: factor out get_sha1_from_index() helper tboegi
@ 2016-05-09 19:54 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-05-09 19:54 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> +#define get_sha1_from_cache(path) get_sha1_from_index (&the_index, (path))
> #endif
Micronit: lose the extra SP; i.e. "get_sha1_from_index(&the_index, (path))".
> diff --git a/read-cache.c b/read-cache.c
> index d9fb78b..a3ef967 100644
> --- a/read-cache.c
> +++ b/read-cache.c
> @@ -2263,13 +2263,27 @@ int index_name_is_other(const struct index_state *istate, const char *name,
>
> void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
> {
> - int pos, len;
> + const unsigned char *sha1;
> unsigned long sz;
> enum object_type type;
> void *data;
>
> - len = strlen(path);
> - pos = index_name_pos(istate, path, len);
> + sha1 = get_sha1_from_index(istate, path);
> + if (!sha1)
> + return NULL;
> + data = read_sha1_file(sha1, &type, &sz);
> + if (!data || type != OBJ_BLOB) {
> + free(data);
> + return NULL;
> + }
> + if (size)
> + *size = sz;
> + return data;
> +}
> +
> +const unsigned char *get_sha1_from_index(struct index_state *istate, const char *path)
> +{
> + int pos = index_name_pos(istate, path, strlen(path));
> if (pos < 0) {
> /*
> * We might be in the middle of a merge, in which
> @@ -2285,14 +2299,7 @@ void *read_blob_data_from_index(struct index_state *istate, const char *path, un
> }
> if (pos < 0)
> return NULL;
> + return (istate->cache[pos]->sha1);
Micronit: lose the extra () pair around what is returned.
I wondered if we can share more code with this helper and
get_sha1_with_context_1(), which is the canonical copy of this logic
used to parse ":$path" and get the object name at $path in the
index, but this is sufficiently low-level and such a refactoring
of small code would not be of great benefit, so this patch is OK.
Thanks.
> }
>
> void stat_validity_clear(struct stat_validity *sv)
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v9 2/6] convert.c: stream and early out
2016-05-07 6:11 ` [PATCH v9 2/6] convert.c: stream and early out tboegi
@ 2016-05-09 20:29 ` Junio C Hamano
2016-05-11 4:30 ` Torsten Bögershausen
0 siblings, 1 reply; 126+ messages in thread
From: Junio C Hamano @ 2016-05-09 20:29 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> + if (stats->stat_bits & earlyout)
> + break; /* We found what we have been searching for */
Are we sure if our callers are only interested in just one bit at a
time? Otherwise, if we want to ensure all of the given bits are
set,
if ((stats->stat_bits & earlyout) == earlyout)
break;
would be necessary. Otherwise, the "only one bit" assumption on the
"earlyout" parameter somehow needs to be documented in the code.
> + ssize_t readlen = read(fd, buf, sizeof(buf));
xread() to automatically retry an interrupted read?
> @@ -309,11 +354,13 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
> {
> char *to_free = NULL;
> struct text_stat stats;
> + unsigned earlyout = CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_BIN;
> +
>
> if (!len || output_eol(crlf_action) != EOL_CRLF)
> return 0;
>
> - gather_stats(src, len, &stats);
> + gather_stats(src, len, &stats, earlyout);
Oops, this answers my earlier question, no?
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v9 2/6] convert.c: stream and early out
2016-05-09 20:29 ` Junio C Hamano
@ 2016-05-11 4:30 ` Torsten Bögershausen
0 siblings, 0 replies; 126+ messages in thread
From: Torsten Bögershausen @ 2016-05-11 4:30 UTC (permalink / raw)
To: Junio C Hamano, tboegi; +Cc: git
On 09.05.16 22:29, Junio C Hamano wrote:
> tboegi@web.de writes:
>
>> + if (stats->stat_bits & earlyout)
>> + break; /* We found what we have been searching for */
>
> Are we sure if our callers are only interested in just one bit at a
> time? Otherwise, if we want to ensure all of the given bits are
> set,
>
> if ((stats->stat_bits & earlyout) == earlyout)
> break;
>
> would be necessary. Otherwise, the "only one bit" assumption on the
> "earlyout" parameter somehow needs to be documented in the code.
Thanks for pointing that out.
I have changed the code a couple of times, forth and back.
I want to re-roll the series anyway (probably in the next weeks),
so something like "search_only_flags" may be a better name.
^ permalink raw reply [flat|nested] 126+ messages in thread
* Re: [PATCH v8 07/10] convert: unify the "auto" handling of CRLF
2016-04-29 15:02 ` [PATCH v8 07/10] convert: unify the "auto" handling of CRLF tboegi
@ 2016-11-25 15:48 ` Torsten Bögershausen
2016-11-27 16:22 ` [PATCH/RFC v1 1/1] New way to normalize the line endings tboegi
2017-04-12 11:48 ` [PATCH v2 1/1] Document how " tboegi
0 siblings, 2 replies; 126+ messages in thread
From: Torsten Bögershausen @ 2016-11-25 15:48 UTC (permalink / raw)
To: tboegi, git
RFH, the normalization as descrived in Documentation/gitattributes.txt
does not work anymore:
From a clean working directory:
-------------------------------------------------
$ 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
$ git add -u
$ git add .gitattributes
$ git commit -m "Introduce end-of-line normalization"
-------------------------------------------------
I have different ideas, how a a normalizatio can be done:
A)
-------------------------------------------------
$ echo "* text=auto" >.gitattributes
$ rm .git/index
$ git add .
$ git status # Show files that will be normalized
$ git commit -m "Introduce end-of-line normalization"
-------------------------------------------------
B)
$ echo "* text=auto" >.gitattributes &&
$ git add .gitattributes &&
$ git ls-files --eol | egrep '^i/(crlf|mixed).*attr/(text|auto)' | ( TAB=$(printf "\t") ; sed -e "s/.*$TAB/dos2unix /" ) >/tmp/$$ &&
$ /bin/sh /tmp/$$ &&
$ rm -f /tmp/$$ &&
$ git add -u &&
$ git commit -m "Introduce end-of-line normalization"
C)
Teach "git add" to learn --renormalize and then
-------------------------------------------------
$ echo "* text=auto" >.gitattributes
$ git add -u --renormalize
$ git add .gitattributes
$ git commit -m "Introduce end-of-line normalization"
-------------------------------------------------
(None of them is really tested)
A) may loose the execute bit
B) dos2unix is not installed everywhere (like Mac OS)
C) seems to most attractive, but I couldn't find out how to forward
options from "git add" into convert.c
Any help is appreciated.
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH/RFC v1 1/1] New way to normalize the line endings
2016-11-25 15:48 ` Torsten Bögershausen
@ 2016-11-27 16:22 ` tboegi
2016-11-29 19:15 ` Junio C Hamano
2017-04-12 11:48 ` [PATCH v2 1/1] Document how " tboegi
1 sibling, 1 reply; 126+ messages in thread
From: tboegi @ 2016-11-27 16:22 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
Sincec commit 6523728499e7 'convert: unify the "auto" handling of CRLF'
the normalization instruction in Documentation/gitattributes.txt
doesn't work any more.
Update the documentation and add a test case.
Reported by Kristian Adrup
https://github.com/git-for-windows/git/issues/954
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/gitattributes.txt | 7 +++----
t/t0025-crlf-auto.sh | 29 +++++++++++++++++++++++++++++
2 files changed, 32 insertions(+), 4 deletions(-)
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index 976243a..1f7529a 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -227,11 +227,10 @@ From a clean working directory:
-------------------------------------------------
$ echo "* text=auto" >.gitattributes
-$ rm .git/index # Remove the index to force Git to
-$ git reset # re-scan the working directory
+$ git ls-files --eol | egrep "i/(crlf|mixed)" # find not normalized files
+$ rm .git/index # Remove the index to re-scan the working directory
+$ git add .
$ git status # Show files that will be normalized
-$ git add -u
-$ git add .gitattributes
$ git commit -m "Introduce end-of-line normalization"
-------------------------------------------------
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index d0bee08..4ad4d02 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -152,4 +152,33 @@ test_expect_success 'eol=crlf _does_ normalize binary files' '
test -z "$LFwithNULdiff"
'
+test_expect_success 'prepare unnormalized' '
+
+ > .gitattributes &&
+ git config core.autocrlf false &&
+ printf "LINEONE\nLINETWO\r\n" >mixed &&
+ git add mixed .gitattributes &&
+ git commit -m "Add mixed" &&
+ git ls-files --eol | egrep "i/crlf" &&
+ git ls-files --eol | egrep "i/mixed"
+
+'
+
+test_expect_success 'normalize unnormalized' '
+ echo "* text=auto" >.gitattributes &&
+ rm .git/index &&
+ git add . &&
+ git commit -m "Introduce end-of-line normalization" &&
+ git ls-files --eol | tr "\\t" " " | sort >act &&
+cat >exp <<EOF &&
+i/-text w/-text attr/text=auto LFwithNUL
+i/lf w/crlf attr/text=auto CRLFonly
+i/lf w/crlf attr/text=auto LFonly
+i/lf w/lf attr/text=auto .gitattributes
+i/lf w/mixed attr/text=auto mixed
+EOF
+ test_cmp exp act
+
+'
+
test_done
--
2.10.0
^ permalink raw reply related [flat|nested] 126+ messages in thread
* Re: [PATCH/RFC v1 1/1] New way to normalize the line endings
2016-11-27 16:22 ` [PATCH/RFC v1 1/1] New way to normalize the line endings tboegi
@ 2016-11-29 19:15 ` Junio C Hamano
0 siblings, 0 replies; 126+ messages in thread
From: Junio C Hamano @ 2016-11-29 19:15 UTC (permalink / raw)
To: tboegi; +Cc: git
tboegi@web.de writes:
> From: Torsten Bögershausen <tboegi@web.de>
>
> Sincec commit 6523728499e7 'convert: unify the "auto" handling of CRLF'
> the normalization instruction in Documentation/gitattributes.txt
> doesn't work any more.
Aside from s/Sincec/Since/, the above made it sound as if the named
commit was a regression that wants to be reverted, at least to my
first reading. I think you want to be a bit more clear that we
updated the world order and made it a better place with that commit,
and examples in the doc need to be updated. To convince readers
that, I think you would need to explain things like why the old way
illustrated in the example was bad, and why the new way is better.
> Update the documentation and add a test case.
>
> Reported by Kristian Adrup
> https://github.com/git-for-windows/git/issues/954
>
> Signed-off-by: Torsten Bögershausen <tboegi@web.de>
> ---
> Documentation/gitattributes.txt | 7 +++----
> t/t0025-crlf-auto.sh | 29 +++++++++++++++++++++++++++++
> 2 files changed, 32 insertions(+), 4 deletions(-)
>
> diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
> index 976243a..1f7529a 100644
> --- a/Documentation/gitattributes.txt
> +++ b/Documentation/gitattributes.txt
> @@ -227,11 +227,10 @@ From a clean working directory:
>
> -------------------------------------------------
> $ echo "* text=auto" >.gitattributes
> -$ rm .git/index # Remove the index to force Git to
> -$ git reset # re-scan the working directory
> +$ git ls-files --eol | egrep "i/(crlf|mixed)" # find not normalized files
Does this step help anything? I do not see anything in the later
steps that the user uses the finding from the output of this step to
affect the end result.
> +$ rm .git/index # Remove the index to re-scan the working directory
> +$ git add .
"A clean working directory" usually means all paths in the index
match what's in the working tree but this requires a bit more than
that, as this step ends up adding untracked and unignored paths.
> $ git status # Show files that will be normalized
> -$ git add -u
> -$ git add .gitattributes
> $ git commit -m "Introduce end-of-line normalization"
> -------------------------------------------------
>
> diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
> index d0bee08..4ad4d02 100755
> --- a/t/t0025-crlf-auto.sh
> +++ b/t/t0025-crlf-auto.sh
> @@ -152,4 +152,33 @@ test_expect_success 'eol=crlf _does_ normalize binary files' '
> test -z "$LFwithNULdiff"
> '
>
> +test_expect_success 'prepare unnormalized' '
> +
> + > .gitattributes &&
Lose SP before ".gitattributes".
> + git config core.autocrlf false &&
> + printf "LINEONE\nLINETWO\r\n" >mixed &&
> + git add mixed .gitattributes &&
> + git commit -m "Add mixed" &&
> + git ls-files --eol | egrep "i/crlf" &&
> + git ls-files --eol | egrep "i/mixed"
> +
> +'
Any particular reason why we must use egrep not grep here?
> +
> +test_expect_success 'normalize unnormalized' '
> + echo "* text=auto" >.gitattributes &&
> + rm .git/index &&
> + git add . &&
> + git commit -m "Introduce end-of-line normalization" &&
> + git ls-files --eol | tr "\\t" " " | sort >act &&
> +cat >exp <<EOF &&
> +i/-text w/-text attr/text=auto LFwithNUL
> +i/lf w/crlf attr/text=auto CRLFonly
> +i/lf w/crlf attr/text=auto LFonly
> +i/lf w/lf attr/text=auto .gitattributes
> +i/lf w/mixed attr/text=auto mixed
> +EOF
Use <<-EOF to indent the above 7 lines?
> + test_cmp exp act
> +
> +'
> +
> test_done
^ permalink raw reply [flat|nested] 126+ messages in thread
* [PATCH v2 1/1] Document how to normalize the line endings
2016-11-25 15:48 ` Torsten Bögershausen
2016-11-27 16:22 ` [PATCH/RFC v1 1/1] New way to normalize the line endings tboegi
@ 2017-04-12 11:48 ` tboegi
1 sibling, 0 replies; 126+ messages in thread
From: tboegi @ 2017-04-12 11:48 UTC (permalink / raw)
To: git; +Cc: Torsten Bögershausen
From: Torsten Bögershausen <tboegi@web.de>
The instructions how to normalize the line endings should have been updated
as part of commit 6523728499e 'convert: unify the "auto" handling of CRLF',
(but that part never made it into the commit).
Update the documentation in Documentation/gitattributes.txt
and add a test case in t0025.
Reported by Kristian Adrup
https://github.com/git-for-windows/git/issues/954
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
---
Documentation/gitattributes.txt | 6 ++----
t/t0025-crlf-auto.sh | 26 ++++++++++++++++++++++++++
2 files changed, 28 insertions(+), 4 deletions(-)
diff --git a/Documentation/gitattributes.txt b/Documentation/gitattributes.txt
index 976243a..3b76687 100644
--- a/Documentation/gitattributes.txt
+++ b/Documentation/gitattributes.txt
@@ -227,11 +227,9 @@ From a clean working directory:
-------------------------------------------------
$ echo "* text=auto" >.gitattributes
-$ rm .git/index # Remove the index to force Git to
-$ git reset # re-scan the working directory
+$ rm .git/index # Remove the index to re-scan the working directory
+$ git add .
$ git status # Show files that will be normalized
-$ git add -u
-$ git add .gitattributes
$ git commit -m "Introduce end-of-line normalization"
-------------------------------------------------
diff --git a/t/t0025-crlf-auto.sh b/t/t0025-crlf-auto.sh
index d0bee08..89826c5 100755
--- a/t/t0025-crlf-auto.sh
+++ b/t/t0025-crlf-auto.sh
@@ -152,4 +152,30 @@ test_expect_success 'eol=crlf _does_ normalize binary files' '
test -z "$LFwithNULdiff"
'
+test_expect_success 'prepare unnormalized' '
+ > .gitattributes &&
+ git config core.autocrlf false &&
+ printf "LINEONE\nLINETWO\r\n" >mixed &&
+ git add mixed .gitattributes &&
+ git commit -m "Add mixed" &&
+ git ls-files --eol | egrep "i/crlf" &&
+ git ls-files --eol | egrep "i/mixed"
+'
+
+test_expect_success 'normalize unnormalized' '
+ echo "* text=auto" >.gitattributes &&
+ rm .git/index &&
+ git add . &&
+ git commit -m "Introduce end-of-line normalization" &&
+ git ls-files --eol | tr "\\t" " " | sort >act &&
+cat >exp <<EOF &&
+i/-text w/-text attr/text=auto LFwithNUL
+i/lf w/crlf attr/text=auto CRLFonly
+i/lf w/crlf attr/text=auto LFonly
+i/lf w/lf attr/text=auto .gitattributes
+i/lf w/mixed attr/text=auto mixed
+EOF
+ test_cmp exp act
+'
+
test_done
--
2.10.0
^ permalink raw reply related [flat|nested] 126+ messages in thread
end of thread, other threads:[~2017-04-12 11:48 UTC | newest]
Thread overview: 126+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <Message-Id=xmqqio26nqk8.fsf@gitster.mtv.corp.google.com>
2016-02-11 16:16 ` [PATCH 1/3] git reset --hard gives clean working tree tboegi
2016-02-11 18:49 ` Junio C Hamano
2016-03-05 7:23 ` Torsten Bögershausen
2016-03-05 8:05 ` Junio C Hamano
2016-03-05 8:27 ` Torsten Bögershausen
2016-03-05 21:18 ` Junio C Hamano
2016-03-07 8:14 ` Junio C Hamano
2016-03-07 8:51 ` Junio C Hamano
2016-03-07 8:58 ` Torsten Bögershausen
2016-03-07 22:34 ` Junio C Hamano
2016-03-29 13:25 ` [PATCH v1 1/7] Make it possible to get sha1 for a path from the index tboegi
2016-03-29 13:28 ` Duy Nguyen
2016-03-29 13:31 ` Duy Nguyen
2016-03-29 15:05 ` Torsten Bögershausen
2016-03-29 19:32 ` Eric Sunshine
2016-03-29 13:25 ` [PATCH v1 2/7] convert.c: stream and early out tboegi
2016-03-29 13:25 ` [PATCH v1 3/7] Allow core.autocrlf=input and core.eol=crlf tboegi
2016-03-29 13:25 ` [PATCH v1 4/7] t0027: TC for combined attributes tboegi
2016-03-29 13:25 ` [PATCH v1 5/7] CRLF: unify the "auto" handling tboegi
2016-03-29 19:42 ` Eric Sunshine
2016-03-29 13:25 ` [PATCH v1 6/7] correct blame for files commited with CRLF tboegi
2016-03-29 17:21 ` Junio C Hamano
2016-03-29 19:51 ` Torsten Bögershausen
2016-03-29 19:58 ` Junio C Hamano
2016-03-29 20:25 ` Junio C Hamano
2016-03-29 20:32 ` Junio C Hamano
2016-03-29 20:50 ` Junio C Hamano
2016-03-30 17:48 ` Torsten Bögershausen
2016-03-29 13:25 ` [PATCH v1 7/7] convert.c: more safer crlf handling with text attribute tboegi
2016-03-29 18:37 ` Junio C Hamano
2016-04-01 16:08 ` [PATCH v2 1/7] Make it possible to get sha1 for a path from the index tboegi
2016-04-01 16:08 ` [PATCH v2 2/7] convert.c: stream and early out tboegi
2016-04-01 16:08 ` [PATCH v2 3/7] Allow core.autocrlf=input and core.eol=crlf tboegi
2016-04-01 22:20 ` Junio C Hamano
2016-04-01 16:08 ` [PATCH v2 4/7] t0027: TC for combined attributes tboegi
2016-04-01 22:22 ` Junio C Hamano
2016-04-01 16:08 ` [PATCH v2 5/7] CRLF: unify the "auto" handling tboegi
2016-04-01 22:25 ` Junio C Hamano
2016-04-01 16:08 ` [PATCH v2 6/7] correct blame for files commited with CRLF tboegi
2016-04-01 22:29 ` Junio C Hamano
2016-04-03 9:29 ` Torsten Bögershausen
2016-04-01 16:08 ` [PATCH v2 7/7] convert.c: more safer crlf handling with text attribute tboegi
2016-04-05 19:23 ` [PATCH v1] correct blame for files commited with CRLF tboegi
2016-04-05 20:57 ` Junio C Hamano
2016-04-05 21:12 ` Junio C Hamano
2016-04-06 4:17 ` Torsten Bögershausen
2016-04-19 13:24 ` [PATCH v5 1/4] t0027: Make more reliable tboegi
2016-04-19 13:26 ` [PATCH v5 2/4] convert: allow core.autocrlf=input and core.eol=crlf tboegi
2016-04-19 13:26 ` [PATCH v5 3/4] t0027: test cases for combined attributes tboegi
2016-04-19 21:32 ` Junio C Hamano
2016-04-20 15:52 ` Torsten Bögershausen
2016-04-19 13:26 ` [PATCH v5 4/4] convert.c: ident + core.autocrlf didn't work tboegi
2016-04-20 22:27 ` Junio C Hamano
2016-04-22 14:38 ` [PATCH v6 01/10] t0027: Make more reliable tboegi
2016-04-22 22:03 ` Junio C Hamano
2016-04-24 3:45 ` Torsten Bögershausen
2016-04-22 14:53 ` [PATCH v6 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
2016-04-22 14:53 ` [PATCH v6 03/10] t0027: test cases for combined attributes tboegi
2016-04-22 14:53 ` [PATCH v6 04/10] convert.c: ident + core.autocrlf didn't work tboegi
2016-04-22 14:53 ` [PATCH v6 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
2016-04-22 14:53 ` [PATCH v6 06/10] convert.c: stream and early out tboegi
2016-04-22 14:53 ` [PATCH v6 07/10] convert: unify the "auto" handling of CRLF tboegi
2016-04-22 14:53 ` [PATCH v6 08/10] convert.c: more safer crlf handling with text attribute tboegi
2016-04-22 14:53 ` [PATCH v6 09/10] t6038; use crlf on all platforms tboegi
2016-04-22 14:53 ` [PATCH v6 10/10] ce_compare_data() did not respect conversion tboegi
2016-04-24 15:10 ` [PATCH v6b 01/10] t0027: Make commit_chk_wrnNNO() reliable tboegi
2016-04-24 15:11 ` [PATCH v6b 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
2016-04-24 15:11 ` [PATCH v6b 03/10] t0027: test cases for combined attributes tboegi
2016-04-24 15:11 ` [PATCH v6b 04/10] convert.c: ident + core.autocrlf didn't work tboegi
2016-04-24 15:11 ` [PATCH v6b 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
2016-04-24 15:11 ` [PATCH v6b 06/10] convert.c: stream and early out tboegi
2016-04-24 15:11 ` [PATCH v6b 07/10] convert: unify the "auto" handling of CRLF tboegi
2016-04-24 15:11 ` [PATCH v6b 08/10] convert.c: more safer crlf handling with text attribute tboegi
2016-04-24 15:11 ` [PATCH v6b 09/10] t6038; use crlf on all platforms tboegi
2016-04-24 15:11 ` [PATCH v6b 10/10] ce_compare_data() did not respect conversion tboegi
2016-04-25 16:56 ` [PATCH v7 01/10] t0027: Make commit_chk_wrnNNO() reliable tboegi
2016-04-25 19:15 ` Junio C Hamano
2016-04-25 16:56 ` [PATCH v7 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
2016-04-25 16:56 ` [PATCH v7 03/10] t0027: test cases for combined attributes tboegi
2016-04-25 16:56 ` [PATCH v7 04/10] convert.c: ident + core.autocrlf didn't work tboegi
2016-04-25 16:56 ` [PATCH v7 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
2016-04-25 16:56 ` [PATCH v7 06/10] convert.c: stream and early out tboegi
2016-04-25 16:56 ` [PATCH v7 07/10] convert: unify the "auto" handling of CRLF tboegi
2016-04-25 19:37 ` Junio C Hamano
2016-04-26 16:33 ` Torsten Bögershausen
2016-04-26 17:42 ` Junio C Hamano
2016-04-25 16:56 ` [PATCH v7 08/10] convert.c: more safer crlf handling with text attribute tboegi
2016-04-25 16:56 ` [PATCH v7 09/10] t6038; use crlf on all platforms tboegi
2016-04-25 16:56 ` [PATCH v7 10/10] ce_compare_data() did not respect conversion tboegi
2016-04-29 15:01 ` [PATCH v8 01/10] t0027: make commit_chk_wrnNNO() reliable tboegi
2016-04-29 15:01 ` [PATCH v8 02/10] convert: allow core.autocrlf=input and core.eol=crlf tboegi
2016-04-29 15:01 ` [PATCH v8 03/10] t0027: test cases for combined attributes tboegi
2016-04-29 15:01 ` [PATCH v8 04/10] convert.c: ident + core.autocrlf didn't work tboegi
2016-04-29 15:02 ` [PATCH v8 05/10] read-cache: factor out get_sha1_from_index() helper tboegi
2016-04-29 15:02 ` [PATCH v8 06/10] convert.c: stream and early out tboegi
2016-04-29 15:02 ` [PATCH v8 07/10] convert: unify the "auto" handling of CRLF tboegi
2016-11-25 15:48 ` Torsten Bögershausen
2016-11-27 16:22 ` [PATCH/RFC v1 1/1] New way to normalize the line endings tboegi
2016-11-29 19:15 ` Junio C Hamano
2017-04-12 11:48 ` [PATCH v2 1/1] Document how " tboegi
2016-04-29 15:02 ` [PATCH v8 08/10] convert.c: more safer crlf handling with text attribute tboegi
2016-04-29 15:02 ` [PATCH v8 09/10] t6038; use crlf on all platforms tboegi
2016-04-29 15:02 ` [PATCH v8 10/10] ce_compare_data() did not respect conversion tboegi
2016-04-29 18:20 ` Junio C Hamano
2016-04-29 21:09 ` Junio C Hamano
2016-05-01 16:27 ` Torsten Bögershausen
2016-05-02 18:16 ` Junio C Hamano
2016-05-02 19:33 ` Junio C Hamano
2016-05-03 16:02 ` Torsten Bögershausen
2016-05-03 18:31 ` Junio C Hamano
2016-05-04 4:07 ` Torsten Bögershausen
2016-05-04 7:23 ` Junio C Hamano
2016-05-06 8:54 ` Torsten Bögershausen
2016-05-06 17:11 ` Junio C Hamano
2016-05-07 6:10 ` [PATCH v9 0/6] convert-eol-autocrlf, old 5..10 now 1..6 tboegi
2016-05-07 6:10 ` [PATCH v9 1/6] read-cache: factor out get_sha1_from_index() helper tboegi
2016-05-09 19:54 ` Junio C Hamano
2016-05-07 6:11 ` [PATCH v9 2/6] convert.c: stream and early out tboegi
2016-05-09 20:29 ` Junio C Hamano
2016-05-11 4:30 ` Torsten Bögershausen
2016-05-07 6:11 ` [PATCH v9 3/6] convert: unify the "auto" handling of CRLF tboegi
2016-05-07 6:11 ` [PATCH v9 4/6] convert.c: more safer crlf handling with text attribute tboegi
2016-05-07 6:11 ` [PATCH v9 5/6] t6038; use crlf on all platforms tboegi
2016-05-07 6:11 ` [PATCH v9 6/6] convert: ce_compare_data() checks for a sha1 of a path tboegi
2016-02-11 16:16 ` [PATCH 2/3] Factor out convert_cmp_checkout() into convert.c tboegi
2016-02-11 16:16 ` [PATCH 3/3] convert.c: Optimize convert_cmp_checkout() for changed file len tboegi
Code repositories for project(s) associated with this public inbox
https://80x24.org/mirrors/git.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).