undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'tb/conversion'

Browse Source 
Code simplification.

* tb/conversion:
  convert.c: correct attr_action()
  convert.c: simplify text_stat
  convert.c: refactor crlf_action
  convert.c: use text_eol_is_crlf()
  convert.c: remove input_crlf_action()
  convert.c: remove unused parameter 'path'
  t0027: add tests for get_stream_filter()
This commit is contained in:
Junio C Hamano 2016-02-26 13:37:23 -08:00
commit c6b94eb009
2 changed files with 270 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

190
convert.c
View File

@ -19,17 +19,19 @@
#define CONVERT_STAT_BITS_BIN 0x4 #define CONVERT_STAT_BITS_BIN 0x4
enum crlf_action { enum crlf_action {
CRLF_GUESS = -1, CRLF_UNDEFINED,
CRLF_BINARY = 0, CRLF_BINARY,
CRLF_TEXT, CRLF_TEXT,
CRLF_INPUT, CRLF_TEXT_INPUT,
CRLF_CRLF, CRLF_TEXT_CRLF,
CRLF_AUTO CRLF_AUTO,
CRLF_AUTO_INPUT,
CRLF_AUTO_CRLF
}; };
struct text_stat { struct text_stat {
/* NUL, CR, LF and CRLF counts */ /* NUL, CR, LF and CRLF counts */
unsigned nul, cr, lf, crlf; unsigned nul, lonecr, lonelf, crlf;
/* These are just approximations! */ /* These are just approximations! */
unsigned printable, nonprintable; unsigned printable, nonprintable;
@ -44,13 +46,15 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
for (i = 0; i < size; i++) { for (i = 0; i < size; i++) {
unsigned char c = buf[i]; unsigned char c = buf[i];
if (c == '\r') { if (c == '\r') {
stats->cr++; if (i+1 < size && buf[i+1] == '\n') {
if (i+1 < size && buf[i+1] == '\n')
stats->crlf++; stats->crlf++;
i++;
} else
stats->lonecr++;
continue; continue;
} }
if (c == '\n') { if (c == '\n') {
stats->lf++; stats->lonelf++;
continue; continue;
} }
if (c == 127) if (c == 127)
@ -84,7 +88,7 @@ static void gather_stats(const char *buf, unsigned long size, struct text_stat *
*/ */
static int convert_is_binary(unsigned long size, const struct text_stat *stats) static int convert_is_binary(unsigned long size, const struct text_stat *stats)
{ {
if (stats->cr != stats->crlf) if (stats->lonecr)
return 1; return 1;
if (stats->nul) if (stats->nul)
return 1; return 1;
@ -96,19 +100,18 @@ static int convert_is_binary(unsigned long size, const struct text_stat *stats)
static unsigned int gather_convert_stats(const char *data, unsigned long size) static unsigned int gather_convert_stats(const char *data, unsigned long size)
{ {
struct text_stat stats; struct text_stat stats;
int ret = 0;
if (!data || !size) if (!data || !size)
return 0; return 0;
gather_stats(data, size, &stats); gather_stats(data, size, &stats);
if (convert_is_binary(size, &stats)) if (convert_is_binary(size, &stats))
return CONVERT_STAT_BITS_BIN; ret |= CONVERT_STAT_BITS_BIN;
else if (stats.crlf && stats.crlf == stats.lf) if (stats.crlf)
return CONVERT_STAT_BITS_TXT_CRLF; ret |= CONVERT_STAT_BITS_TXT_CRLF;
else if (stats.crlf && stats.lf) if (stats.lonelf)
return CONVERT_STAT_BITS_TXT_CRLF | CONVERT_STAT_BITS_TXT_LF; ret |= CONVERT_STAT_BITS_TXT_LF;
else if (stats.lf)
return CONVERT_STAT_BITS_TXT_LF; return ret;
else
return 0;
} }
static const char *gather_convert_stats_ascii(const char *data, unsigned long size) static const char *gather_convert_stats_ascii(const char *data, unsigned long size)
@ -149,28 +152,37 @@ const char *get_wt_convert_stats_ascii(const char *path)
return ret; return ret;
} }
static int text_eol_is_crlf(void)
{
if (auto_crlf == AUTO_CRLF_TRUE)
return 1;
else if (auto_crlf == AUTO_CRLF_INPUT)
return 0;
if (core_eol == EOL_CRLF)
return 1;
if (core_eol == EOL_UNSET && EOL_NATIVE == EOL_CRLF)
return 1;
return 0;
}
static enum eol output_eol(enum crlf_action crlf_action) static enum eol output_eol(enum crlf_action crlf_action)
{ {
switch (crlf_action) { switch (crlf_action) {
case CRLF_BINARY: case CRLF_BINARY:
return EOL_UNSET; return EOL_UNSET;
case CRLF_CRLF: case CRLF_TEXT_CRLF:
return EOL_CRLF; return EOL_CRLF;
case CRLF_INPUT: case CRLF_TEXT_INPUT:
return EOL_LF; return EOL_LF;
case CRLF_GUESS: case CRLF_UNDEFINED:
if (!auto_crlf) case CRLF_AUTO_CRLF:
return EOL_UNSET; case CRLF_AUTO_INPUT:
/* fall through */
case CRLF_TEXT: case CRLF_TEXT:
case CRLF_AUTO: case CRLF_AUTO:
if (auto_crlf == AUTO_CRLF_TRUE) /* fall through */
return EOL_CRLF; return text_eol_is_crlf() ? EOL_CRLF : EOL_LF;
else if (auto_crlf == AUTO_CRLF_INPUT)
return EOL_LF;
else if (core_eol == EOL_UNSET)
return EOL_NATIVE;
} }
warning("Illegal crlf_action %d\n", (int)crlf_action);
return core_eol; return core_eol;
} }
@ -196,7 +208,7 @@ static void check_safe_crlf(const char *path, enum crlf_action crlf_action,
* CRLFs would be added by checkout: * CRLFs would be added by checkout:
* check if we have "naked" LFs * check if we have "naked" LFs
*/ */
if (stats->lf != stats->crlf) { if (stats->lonelf) {
if (checksafe == SAFE_CRLF_WARN) 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); 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 */ else /* i.e. SAFE_CRLF_FAIL */
@ -227,7 +239,6 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
char *dst; char *dst;
if (crlf_action == CRLF_BINARY || if (crlf_action == CRLF_BINARY ||
(crlf_action == CRLF_GUESS && auto_crlf == AUTO_CRLF_FALSE) ||
(src && !len)) (src && !len))
return 0; return 0;
@ -240,11 +251,11 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
gather_stats(src, len, &stats); gather_stats(src, len, &stats);
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS) { if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
if (convert_is_binary(len, &stats)) if (convert_is_binary(len, &stats))
return 0; return 0;
if (crlf_action == CRLF_GUESS) { 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. * If the file in the index has any CR in it, do not convert.
* This is the new safer autocrlf handling. * This is the new safer autocrlf handling.
@ -256,8 +267,8 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
check_safe_crlf(path, crlf_action, &stats, checksafe); check_safe_crlf(path, crlf_action, &stats, checksafe);
/* Optimization: No CR? Nothing to convert, regardless. */ /* Optimization: No CRLF? Nothing to convert, regardless. */
if (!stats.cr) if (!stats.crlf)
return 0; return 0;
/* /*
@ -271,7 +282,7 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
if (strbuf_avail(buf) + buf->len < len) if (strbuf_avail(buf) + buf->len < len)
strbuf_grow(buf, len - buf->len); strbuf_grow(buf, len - buf->len);
dst = buf->buf; dst = buf->buf;
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS) { 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 * If we guessed, we already know we rejected a file with
* lone CR, and we can strip a CR without looking at what * lone CR, and we can strip a CR without looking at what
@ -304,19 +315,15 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
gather_stats(src, len, &stats); gather_stats(src, len, &stats);
/* No LF? Nothing to convert, regardless. */ /* No "naked" LF? Nothing to convert, regardless. */
if (!stats.lf) if (!stats.lonelf)
return 0; return 0;
/* Was it already in CRLF format? */ if (crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
if (stats.lf == stats.crlf) if (crlf_action == CRLF_AUTO_INPUT || crlf_action == CRLF_AUTO_CRLF) {
return 0;
if (crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS) {
if (crlf_action == CRLF_GUESS) {
/* If we have any CR or CRLF line endings, we do not touch it */ /* If we have any CR or CRLF line endings, we do not touch it */
/* This is the new safer autocrlf-handling */ /* This is the new safer autocrlf-handling */
if (stats.cr > 0 || stats.crlf > 0) if (stats.lonecr || stats.crlf )
return 0; return 0;
} }
@ -328,7 +335,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
if (src == buf->buf) if (src == buf->buf)
to_free = strbuf_detach(buf, NULL); to_free = strbuf_detach(buf, NULL);
strbuf_grow(buf, len + stats.lf - stats.crlf); strbuf_grow(buf, len + stats.lonelf);
for (;;) { for (;;) {
const char *nl = memchr(src, '\n', len); const char *nl = memchr(src, '\n', len);
if (!nl) if (!nl)
@ -696,7 +703,7 @@ static int ident_to_worktree(const char *path, const char *src, size_t len,
return 1; return 1;
} }
static enum crlf_action git_path_check_crlf(const char *path, struct git_attr_check *check) static enum crlf_action git_path_check_crlf(struct git_attr_check *check)
{ {
const char *value = check->value; const char *value = check->value;
@ -707,13 +714,13 @@ static enum crlf_action git_path_check_crlf(const char *path, struct git_attr_ch
else if (ATTR_UNSET(value)) else if (ATTR_UNSET(value))
; ;
else if (!strcmp(value, "input")) else if (!strcmp(value, "input"))
return CRLF_INPUT; return CRLF_TEXT_INPUT;
else if (!strcmp(value, "auto")) else if (!strcmp(value, "auto"))
return CRLF_AUTO; return CRLF_AUTO;
return CRLF_GUESS; return CRLF_UNDEFINED;
} }
static enum eol git_path_check_eol(const char *path, struct git_attr_check *check) static enum eol git_path_check_eol(struct git_attr_check *check)
{ {
const char *value = check->value; const char *value = check->value;
@ -726,8 +733,7 @@ static enum eol git_path_check_eol(const char *path, struct git_attr_check *chec
return EOL_UNSET; return EOL_UNSET;
} }
static struct convert_driver *git_path_check_convert(const char *path, static struct convert_driver *git_path_check_convert(struct git_attr_check *check)
struct git_attr_check *check)
{ {
const char *value = check->value; const char *value = check->value;
struct convert_driver *drv; struct convert_driver *drv;
@ -740,28 +746,17 @@ static struct convert_driver *git_path_check_convert(const char *path,
return NULL; return NULL;
} }
static int git_path_check_ident(const char *path, struct git_attr_check *check) static int git_path_check_ident(struct git_attr_check *check)
{ {
const char *value = check->value; const char *value = check->value;
return !!ATTR_TRUE(value); return !!ATTR_TRUE(value);
} }
static enum crlf_action input_crlf_action(enum crlf_action text_attr, enum eol eol_attr)
{
if (text_attr == CRLF_BINARY)
return CRLF_BINARY;
if (eol_attr == EOL_LF)
return CRLF_INPUT;
if (eol_attr == EOL_CRLF)
return CRLF_CRLF;
return text_attr;
}
struct conv_attrs { struct conv_attrs {
struct convert_driver *drv; struct convert_driver *drv;
enum crlf_action crlf_action; enum crlf_action attr_action; /* What attr says */
enum eol eol_attr; enum crlf_action crlf_action; /* When no attr is set, use core.autocrlf */
int ident; int ident;
}; };
@ -783,18 +778,33 @@ static void convert_attrs(struct conv_attrs *ca, const char *path)
} }
if (!git_check_attr(path, NUM_CONV_ATTRS, ccheck)) { if (!git_check_attr(path, NUM_CONV_ATTRS, ccheck)) {
ca->crlf_action = git_path_check_crlf(path, ccheck + 4); ca->crlf_action = git_path_check_crlf(ccheck + 4);
if (ca->crlf_action == CRLF_GUESS) if (ca->crlf_action == CRLF_UNDEFINED)
ca->crlf_action = git_path_check_crlf(path, ccheck + 0); ca->crlf_action = git_path_check_crlf(ccheck + 0);
ca->ident = git_path_check_ident(path, ccheck + 1); ca->attr_action = ca->crlf_action;
ca->drv = git_path_check_convert(path, ccheck + 2); ca->ident = git_path_check_ident(ccheck + 1);
ca->eol_attr = git_path_check_eol(path, ccheck + 3); 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)
ca->crlf_action = CRLF_TEXT_INPUT;
else if (eol_attr == EOL_CRLF)
ca->crlf_action = CRLF_TEXT_CRLF;
}
ca->attr_action = ca->crlf_action;
} else { } else {
ca->drv = NULL; ca->drv = NULL;
ca->crlf_action = CRLF_GUESS; ca->crlf_action = CRLF_UNDEFINED;
ca->eol_attr = EOL_UNSET;
ca->ident = 0; ca->ident = 0;
} }
if (ca->crlf_action == CRLF_TEXT)
ca->crlf_action = text_eol_is_crlf() ? CRLF_TEXT_CRLF : CRLF_TEXT_INPUT;
if (ca->crlf_action == CRLF_UNDEFINED && auto_crlf == AUTO_CRLF_FALSE)
ca->crlf_action = CRLF_BINARY;
if (ca->crlf_action == CRLF_UNDEFINED && auto_crlf == AUTO_CRLF_TRUE)
ca->crlf_action = CRLF_AUTO_CRLF;
if (ca->crlf_action == CRLF_UNDEFINED && auto_crlf == AUTO_CRLF_INPUT)
ca->crlf_action = CRLF_AUTO_INPUT;
} }
int would_convert_to_git_filter_fd(const char *path) int would_convert_to_git_filter_fd(const char *path)
@ -819,23 +829,25 @@ int would_convert_to_git_filter_fd(const char *path)
const char *get_convert_attr_ascii(const char *path) const char *get_convert_attr_ascii(const char *path)
{ {
struct conv_attrs ca; struct conv_attrs ca;
enum crlf_action crlf_action;
convert_attrs(&ca, path); convert_attrs(&ca, path);
crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr); switch (ca.attr_action) {
switch (crlf_action) { case CRLF_UNDEFINED:
case CRLF_GUESS:
return ""; return "";
case CRLF_BINARY: case CRLF_BINARY:
return "-text"; return "-text";
case CRLF_TEXT: case CRLF_TEXT:
return "text"; return "text";
case CRLF_INPUT: case CRLF_TEXT_INPUT:
return "text eol=lf"; return "text eol=lf";
case CRLF_CRLF: case CRLF_TEXT_CRLF:
return "text=auto eol=crlf"; return "text eol=crlf";
case CRLF_AUTO: case CRLF_AUTO:
return "text=auto"; return "text=auto";
case CRLF_AUTO_CRLF:
return "text=auto eol=crlf"; /* This is not supported yet */
case CRLF_AUTO_INPUT:
return "text=auto eol=lf"; /* This is not supported yet */
} }
return ""; return "";
} }
@ -862,7 +874,6 @@ int convert_to_git(const char *path, const char *src, size_t len,
src = dst->buf; src = dst->buf;
len = dst->len; len = dst->len;
} }
ca.crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr);
ret |= crlf_to_git(path, src, len, dst, ca.crlf_action, checksafe); ret |= crlf_to_git(path, src, len, dst, ca.crlf_action, checksafe);
if (ret && dst) { if (ret && dst) {
src = dst->buf; src = dst->buf;
@ -883,7 +894,6 @@ 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)) if (!apply_filter(path, NULL, 0, fd, dst, ca.drv->clean))
die("%s: clean filter '%s' failed", path, ca.drv->name); die("%s: clean filter '%s' failed", path, ca.drv->name);
ca.crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr);
crlf_to_git(path, dst->buf, dst->len, dst, ca.crlf_action, checksafe); crlf_to_git(path, dst->buf, dst->len, dst, ca.crlf_action, checksafe);
ident_to_git(path, dst->buf, dst->len, dst, ca.ident); ident_to_git(path, dst->buf, dst->len, dst, ca.ident);
} }
@ -913,7 +923,6 @@ static int convert_to_working_tree_internal(const char *path, const char *src,
* is a smudge filter. The filter might expect CRLFs. * is a smudge filter. The filter might expect CRLFs.
*/ */
if (filter || !normalizing) { if (filter || !normalizing) {
ca.crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr);
ret |= crlf_to_worktree(path, src, len, dst, ca.crlf_action); ret |= crlf_to_worktree(path, src, len, dst, ca.crlf_action);
if (ret) { if (ret) {
src = dst->buf; src = dst->buf;
@ -1382,14 +1391,15 @@ struct stream_filter *get_stream_filter(const char *path, const unsigned char *s
if (ca.ident) if (ca.ident)
filter = ident_filter(sha1); filter = ident_filter(sha1);
crlf_action = input_crlf_action(ca.crlf_action, ca.eol_attr); crlf_action = ca.crlf_action;
if ((crlf_action == CRLF_BINARY) || (crlf_action == CRLF_INPUT) || if ((crlf_action == CRLF_BINARY) ||
(crlf_action == CRLF_GUESS && auto_crlf == AUTO_CRLF_FALSE)) crlf_action == CRLF_AUTO_INPUT ||
(crlf_action == CRLF_TEXT_INPUT))
filter = cascade_filter(filter, &null_filter_singleton); filter = cascade_filter(filter, &null_filter_singleton);
else if (output_eol(crlf_action) == EOL_CRLF && else if (output_eol(crlf_action) == EOL_CRLF &&
!(crlf_action == CRLF_AUTO || crlf_action == CRLF_GUESS)) !(crlf_action == CRLF_AUTO || crlf_action == CRLF_AUTO_CRLF))
filter = cascade_filter(filter, lf_to_crlf_filter()); filter = cascade_filter(filter, lf_to_crlf_filter());
return filter; return filter;

304
t/t0027-auto-crlf.sh
View File

@ -21,38 +21,32 @@ compare_ws_file () {
pfx=$1 pfx=$1
exp=$2.expect exp=$2.expect
act=$pfx.actual.$3 act=$pfx.actual.$3
tr '\015\000' QN <"$2" >"$exp" && tr '\015\000abcdef0123456789' QN00000000000000000 <"$2" >"$exp" &&
tr '\015\000' QN <"$3" >"$act" && tr '\015\000abcdef0123456789' QN00000000000000000 <"$3" >"$act" &&
test_cmp $exp $act && test_cmp "$exp" "$act" &&
rm $exp $act rm "$exp" "$act"
} }
create_gitattributes () { create_gitattributes () {
attr=$1 {
case "$attr" in while test "$#" != 0
auto) do
echo "*.txt text=auto" >.gitattributes case "$1" in
;; auto) echo '*.txt text=auto' ;;
text) ident) echo '*.txt ident' ;;
echo "*.txt text" >.gitattributes text) echo '*.txt text' ;;
;; -text) echo '*.txt -text' ;;
-text) crlf) echo '*.txt eol=crlf' ;;
echo "*.txt -text" >.gitattributes lf) echo '*.txt eol=lf' ;;
;; "") ;;
crlf)
echo "*.txt eol=crlf" >.gitattributes
;;
lf)
echo "*.txt eol=lf" >.gitattributes
;;
"")
echo >.gitattributes
;;
*) *)
echo >&2 invalid attribute: $attr echo >&2 invalid attribute: "$1"
exit 1 exit 1
;; ;;
esac esac &&
shift
done
} >.gitattributes
} }
create_NNO_files () { create_NNO_files () {
@ -165,6 +159,25 @@ stats_ascii () {
} }
# contruct the attr/ returned by git ls-files --eol
# Take none (=empty), one or two args
attr_ascii () {
case $1,$2 in
-text,*) echo "-text" ;;
text,) echo "text" ;;
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" ;;
lf,) echo "text eol=lf" ;;
crlf,) echo "text eol=crlf" ;;
,) echo "" ;;
*) echo invalid_attr "$1,$2" ;;
esac
}
check_files_in_repo () { check_files_in_repo () {
crlf=$1 crlf=$1
attr=$2 attr=$2
@ -208,55 +221,57 @@ check_in_repo_NNO () {
} }
checkout_files () { checkout_files () {
eol=$1 attr=$1 ; shift
crlf=$2 ident=$1; shift
attr=$3 aeol=$1 ; shift
lfname=$4 crlf=$1 ; shift
crlfname=$5 ceol=$1 ; shift
lfmixcrlf=$6 lfname=$1 ; shift
lfmixcr=$7 crlfname=$1 ; shift
crlfnul=$8 lfmixcrlf=$1 ; shift
create_gitattributes $attr && lfmixcr=$1 ; shift
crlfnul=$1 ; shift
create_gitattributes "$attr" "$ident" &&
git config core.autocrlf $crlf && git config core.autocrlf $crlf &&
pfx=eol_${eol}_crlf_${crlf}_attr_${attr}_ && pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
do do
rm crlf_false_attr__$f.txt && rm crlf_false_attr__$f.txt &&
if test -z "$eol"; then if test -z "$ceol"; then
git checkout crlf_false_attr__$f.txt git checkout crlf_false_attr__$f.txt
else else
git -c core.eol=$eol checkout crlf_false_attr__$f.txt git -c core.eol=$ceol checkout crlf_false_attr__$f.txt
fi fi
done done
test_expect_success "ls-files --eol $lfname ${pfx}LF.txt" ' test_expect_success "ls-files --eol attr=$attr $ident $aeol core.autocrlf=$crlf core.eol=$ceol" '
test_when_finished "rm expect actual" && test_when_finished "rm expect actual" &&
sort <<-EOF >expect && sort <<-EOF >expect &&
i/crlf w/$(stats_ascii $crlfname) crlf_false_attr__CRLF.txt i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
i/mixed w/$(stats_ascii $lfmixcrlf) crlf_false_attr__CRLF_mix_LF.txt i/mixed w/$(stats_ascii $lfmixcrlf) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF_mix_LF.txt
i/lf w/$(stats_ascii $lfname) crlf_false_attr__LF.txt i/lf w/$(stats_ascii $lfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__LF.txt
i/-text w/$(stats_ascii $lfmixcr) crlf_false_attr__LF_mix_CR.txt i/-text w/$(stats_ascii $lfmixcr) attr/$(attr_ascii $attr $aeol) crlf_false_attr__LF_mix_CR.txt
i/-text w/$(stats_ascii $crlfnul) crlf_false_attr__CRLF_nul.txt i/-text w/$(stats_ascii $crlfnul) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF_nul.txt
i/-text w/$(stats_ascii $crlfnul) crlf_false_attr__LF_nul.txt i/-text w/$(stats_ascii $crlfnul) attr/$(attr_ascii $attr $aeol) crlf_false_attr__LF_nul.txt
EOF EOF
git ls-files --eol crlf_false_attr__* | git ls-files --eol crlf_false_attr__* |
sed -e "s!attr/[^ ]*!!g" -e "s/ / /g" -e "s/ */ /g" | sed -e "s/ / /g" -e "s/ */ /g" |
sort >actual && sort >actual &&
test_cmp expect actual test_cmp expect actual
' '
test_expect_success "checkout core.eol=$eol core.autocrlf=$crlf gitattributes=$attr file=LF" " test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
compare_ws_file $pfx $lfname crlf_false_attr__LF.txt compare_ws_file $pfx $lfname crlf_false_attr__LF.txt
" "
test_expect_success "checkout core.eol=$eol core.autocrlf=$crlf gitattributes=$attr file=CRLF" " test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
compare_ws_file $pfx $crlfname crlf_false_attr__CRLF.txt compare_ws_file $pfx $crlfname crlf_false_attr__CRLF.txt
" "
test_expect_success "checkout core.eol=$eol core.autocrlf=$crlf gitattributes=$attr file=CRLF_mix_LF" " test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
compare_ws_file $pfx $lfmixcrlf crlf_false_attr__CRLF_mix_LF.txt compare_ws_file $pfx $lfmixcrlf crlf_false_attr__CRLF_mix_LF.txt
" "
test_expect_success "checkout core.eol=$eol core.autocrlf=$crlf gitattributes=$attr file=LF_mix_CR" " test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
compare_ws_file $pfx $lfmixcr crlf_false_attr__LF_mix_CR.txt compare_ws_file $pfx $lfmixcr crlf_false_attr__LF_mix_CR.txt
" "
test_expect_success "checkout core.eol=$eol core.autocrlf=$crlf gitattributes=$attr file=LF_nul" " test_expect_success "checkout $ident $attr $aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
compare_ws_file $pfx $crlfnul crlf_false_attr__LF_nul.txt compare_ws_file $pfx $crlfnul crlf_false_attr__LF_nul.txt
" "
} }
@ -301,14 +316,13 @@ test_expect_success 'setup master' '
git checkout -b master && git checkout -b master &&
git add .gitattributes && git add .gitattributes &&
git commit -m "add .gitattributes" "" && git commit -m "add .gitattributes" "" &&
printf "line1\nline2\nline3" >LF && printf "\$Id: 0000000000000000000000000000000000000000 \$\nLINEONE\nLINETWO\nLINETHREE" >LF &&
printf "line1\r\nline2\r\nline3" >CRLF && printf "\$Id: 0000000000000000000000000000000000000000 \$\r\nLINEONE\r\nLINETWO\r\nLINETHREE" >CRLF &&
printf "line1\r\nline2\nline3" >repoMIX && printf "\$Id: 0000000000000000000000000000000000000000 \$\nLINEONE\r\nLINETWO\nLINETHREE" >CRLF_mix_LF &&
printf "line1\r\nline2\nline3" >CRLF_mix_LF && printf "\$Id: 0000000000000000000000000000000000000000 \$\nLINEONE\nLINETWO\rLINETHREE" >LF_mix_CR &&
printf "line1\nline2\rline3" >LF_mix_CR && printf "\$Id: 0000000000000000000000000000000000000000 \$\r\nLINEONE\r\nLINETWO\rLINETHREE" >CRLF_mix_CR &&
printf "line1\r\nline2\rline3" >CRLF_mix_CR && printf "\$Id: 0000000000000000000000000000000000000000 \$\r\nLINEONEQ\r\nLINETWO\r\nLINETHREE" | q_to_nul >CRLF_nul &&
printf "line1Q\r\nline2\r\nline3" | q_to_nul >CRLF_nul && printf "\$Id: 0000000000000000000000000000000000000000 \$\nLINEONEQ\nLINETWO\nLINETHREE" | q_to_nul >LF_nul &&
printf "line1Q\nline2\nline3" | q_to_nul >LF_nul &&
create_NNO_files CRLF_mix_LF CRLF_mix_LF CRLF_mix_LF CRLF_mix_LF CRLF_mix_LF && create_NNO_files CRLF_mix_LF CRLF_mix_LF CRLF_mix_LF CRLF_mix_LF CRLF_mix_LF &&
git -c core.autocrlf=false add NNO_*.txt && git -c core.autocrlf=false add NNO_*.txt &&
git commit -m "mixed line endings" && git commit -m "mixed line endings" &&
@ -449,23 +463,18 @@ check_in_repo_NNO input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF
# How to read the table below: # How to read the table below:
# - checkout_files will check multiple files with a combination of settings # - checkout_files will check multiple files with a combination of settings
# and attributes (core.autocrlf=input is forbidden with core.eol=crlf) # and attributes (core.autocrlf=input is forbidden with core.eol=crlf)
# - parameter $1 : core.eol lf | crlf #
# - parameter $2 : core.autocrlf false | true | input # - parameter $1 : text in .gitattributs "" (empty) | auto | text | -text
# - parameter $3 : text in .gitattributs "" (empty) | auto | text | -text # - parameter $2 : ident "" | i (i == ident)
# - parameter $4 : reference for a file with only LF in the repo # - parameter $3 : eol in .gitattributs "" (empty) | lf | crlf
# - parameter $5 : reference for a file with only CRLF in the repo # - parameter $4 : core.autocrlf false | true | input
# - parameter $6 : reference for a file with mixed LF and CRLF in the repo # - parameter $5 : core.eol "" | lf | crlf | "native"
# - parameter $7 : reference for a file with LF and CR in the repo (does somebody uses this ?) # - parameter $6 : reference for a file with only LF in the repo
# - parameter $8 : reference for a file with CRLF and a NUL (should be handled as binary when auto) # - parameter $7 : reference for a file with only CRLF in the repo
# - parameter $8 : reference for a file with mixed LF and CRLF in the repo
# - parameter $9 : reference for a file with LF and CR in the repo
# - parameter $10 : reference for a file with CRLF and a NUL (should be handled as binary when auto)
# What we have in the repo:
# ----------------- EOL in repo ----------------
# LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
# settings with checkout:
# core. core. .gitattr
# eol acrlf
# ----------------------------------------------
# What we want to have in the working tree:
if test_have_prereq NATIVE_CRLF if test_have_prereq NATIVE_CRLF
then then
MIX_CRLF_LF=CRLF MIX_CRLF_LF=CRLF
@ -480,69 +489,90 @@ LFNUL=LF_nul
fi fi
export CRLF_MIX_LF_CR MIX NL export CRLF_MIX_LF_CR MIX NL
checkout_files lf false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul checkout_files "" "" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files lf true "" CRLF 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 lf input "" 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 lf false "auto" 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 lf true "auto" CRLF CRLF CRLF LF_mix_CR LF_nul checkout_files "" "" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files lf input "auto" 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 lf false "text" 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 lf true "text" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul checkout_files "" "" "" true crlf CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files lf input "text" LF 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 lf false "-text" LF 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 lf true "-text" LF 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 lf input "-text" 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 lf false "lf" 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 lf true "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 lf input "lf" 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 lf false "crlf" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul checkout_files "" ident "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files lf true "crlf" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul checkout_files "" ident "" true "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files lf input "crlf" CRLF CRLF CRLF CRLF_mix_CR CRLF_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
checkout_files crlf false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul for id in "" ident;
checkout_files crlf true "" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul do
checkout_files crlf false "auto" CRLF CRLF CRLF LF_mix_CR LF_nul checkout_files "crlf" "$id" "" false "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
checkout_files crlf true "auto" CRLF CRLF CRLF LF_mix_CR LF_nul checkout_files "crlf" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
checkout_files crlf false "text" 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 true "text" 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 false "-text" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul checkout_files "crlf" "$id" "" input "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
checkout_files crlf true "-text" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul checkout_files "crlf" "$id" "" input lf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
checkout_files crlf false "lf" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul checkout_files "crlf" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
checkout_files crlf true "lf" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul checkout_files "crlf" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
checkout_files crlf false "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 true "crlf" 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 "" 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 "" true "" CRLF 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 "" input "" 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 "" false "auto" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul checkout_files "lf" "$id" "" input "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "" true "auto" CRLF CRLF CRLF LF_mix_CR LF_nul checkout_files "lf" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "" input "auto" 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 "" false "text" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL checkout_files "lf" "$id" "" true crlf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "" true "text" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul checkout_files "lf" "$id" "" true lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files "" input "text" 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 "" false "-text" 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 "" true "-text" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul checkout_files "text" "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
checkout_files "" input "-text" 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 "" 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 "" true "lf" 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 "" input "lf" 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 "" false "crlf" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul checkout_files "text" "$id" "" true "" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
checkout_files "" true "crlf" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul checkout_files "text" "$id" "" true crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
checkout_files "" input "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 native false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul checkout_files "-text" "$id" "" false "" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files native true "" CRLF 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 native false "auto" $NL CRLF $MIX_CRLF_LF LF_mix_CR LF_nul checkout_files "-text" "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files native true "auto" CRLF CRLF CRLF LF_mix_CR LF_nul checkout_files "-text" "$id" "" false native LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files native false "text" $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 native true "text" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul checkout_files "-text" "$id" "" input lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
checkout_files native false "-text" 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 native true "-text" 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 native false "lf" 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 native 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
checkout_files native false "crlf" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul done
checkout_files native true "crlf" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
# Should be the last test case: remove some files from the worktree # Should be the last test case: remove some files from the worktree
test_expect_success 'ls-files --eol -d -z' ' test_expect_success 'ls-files --eol -d -z' '