kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity
Browse Source

Rename the "crlf" attribute "text" 

As discussed on the list, "crlf" is not an optimal name.  Linus
suggested "text", which is much better.

Signed-off-by: Eyvind Bernhardsen <eyvind.bernhardsen@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Eyvind Bernhardsen 15 years ago committed by Junio C Hamano
parent
fd6cce9e89
commit
5ec3e67052
7 changed files with 91 additions and 56 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      Documentation/config.txt
  2. 13
      Documentation/git-cvsserver.txt
  3. 59
      Documentation/gitattributes.txt
  4. 2
      attr.c
  5. 23
      convert.c
  6. 13
      git-cvsserver.perl
  7. 21
      t/t0025-crlf-auto.sh

16
Documentation/config.txt
Unescape View File

@ -199,7 +199,7 @@ core.autocrlf::
reading from the filesystem but files are written out with reading from the filesystem but files are written out with
`LF` at the end of lines. A file is considered `LF` at the end of lines. A file is considered
"text" (i.e. be subjected to the autocrlf mechanism) based on "text" (i.e. be subjected to the autocrlf mechanism) based on
the file's `crlf` attribute, or if `crlf` is unspecified, the file's `text` attribute, or if `text` is unspecified,
based on the file's contents. See linkgit:gitattributes[5]. based on the file's contents. See linkgit:gitattributes[5].


core.safecrlf:: core.safecrlf::
@ -943,13 +943,15 @@ gitcvs.logfile::
various stuff. See linkgit:git-cvsserver[1]. various stuff. See linkgit:git-cvsserver[1].


gitcvs.usecrlfattr:: gitcvs.usecrlfattr::
If true, the server will look up the `crlf` attribute for If true, the server will look up the end-of-line conversion
files to determine the '-k' modes to use. If `crlf` is set, attributes for files to determine the '-k' modes to use. If
the '-k' mode will be left blank, so cvs clients will the attributes force git to treat a file as text,
treat it as text. If `crlf` is explicitly unset, the file the '-k' mode will be left blank so cvs clients will
treat it as text. If they suppress text conversion, the file
will be set with '-kb' mode, which suppresses any newline munging will be set with '-kb' mode, which suppresses any newline munging
the client might otherwise do. If `crlf` is not specified, the client might otherwise do. If the attributes do not allow
then 'gitcvs.allbinary' is used. See linkgit:gitattributes[5]. the file type to be determined, then 'gitcvs.allbinary' is
used. See linkgit:gitattributes[5].


gitcvs.allbinary:: gitcvs.allbinary::
This is used if 'gitcvs.usecrlfattr' does not resolve This is used if 'gitcvs.usecrlfattr' does not resolve

13
Documentation/git-cvsserver.txt
Unescape View File

@ -340,16 +340,13 @@ By default the server leaves the '-k' mode blank for all files,
which causes the cvs client to treat them as a text files, subject which causes the cvs client to treat them as a text files, subject
to crlf conversion on some platforms. to crlf conversion on some platforms.


You can make the server use `crlf` attributes to set the '-k' modes You can make the server use the end-of-line conversion attributes to
for files by setting the `gitcvs.usecrlfattr` config variable. set the '-k' modes for files by setting the `gitcvs.usecrlfattr`
In this case, if `crlf` is explicitly unset ('-crlf'), then the config variable. See linkgit:gitattributes[5] for more information
server will set '-kb' mode for binary files. If `crlf` is set, about end-of-line conversion.
then the '-k' mode will explicitly be left blank. See
also linkgit:gitattributes[5] for more information about the `crlf`
attribute.


Alternatively, if `gitcvs.usecrlfattr` config is not enabled Alternatively, if `gitcvs.usecrlfattr` config is not enabled
or if the `crlf` attribute is unspecified for a filename, then or the attributes do not allow automatic detection for a filename, then
the server uses the `gitcvs.allbinary` config for the default setting. the server uses the `gitcvs.allbinary` config for the default setting.
If `gitcvs.allbinary` is set, then file not otherwise If `gitcvs.allbinary` is set, then file not otherwise
specified will default to '-kb' mode. Otherwise the '-k' mode specified will default to '-kb' mode. Otherwise the '-k' mode

59
Documentation/gitattributes.txt
Unescape View File

@ -92,7 +92,7 @@ such as 'git checkout' and 'git merge' run. They also affect how
git stores the contents you prepare in the working tree in the git stores the contents you prepare in the working tree in the
repository upon 'git add' and 'git commit'. repository upon 'git add' and 'git commit'.


`crlf` `text`
^^^^^^ ^^^^^^


This attribute enables and controls end-of-line normalization. When a This attribute enables and controls end-of-line normalization. When a
@ -103,28 +103,28 @@ directory, use the `eol` attribute for a single file and the


Set:: Set::


Setting the `crlf` attribute on a path enables end-of-line Setting the `text` attribute on a path enables end-of-line
normalization and marks the path as a text file. End-of-line normalization and marks the path as a text file. End-of-line
conversion takes place without guessing the content type. conversion takes place without guessing the content type.


Unset:: Unset::


Unsetting the `crlf` attribute on a path tells git not to Unsetting the `text` attribute on a path tells git not to
attempt any end-of-line conversion upon checkin or checkout. attempt any end-of-line conversion upon checkin or checkout.


Set to string value "auto":: Set to string value "auto"::


When `crlf` is set to "auto", the path is marked for automatic When `text` is set to "auto", the path is marked for automatic
end-of-line normalization. If git decides that the content is end-of-line normalization. If git decides that the content is
text, its line endings are normalized to LF on checkin. text, its line endings are normalized to LF on checkin.


Unspecified:: Unspecified::


If the `crlf` attribute is unspecified, git uses the `eol` If the `text` attribute is unspecified, git uses the `eol`
attribute and the `core.autocrlf` configuration variable to attribute and the `core.autocrlf` configuration variable to
determine if the file should be converted. determine if the file should be converted.


Any other value causes git to act as if `crlf` has been left Any other value causes git to act as if `text` has been left
unspecified. unspecified.


`eol` `eol`
@ -132,20 +132,31 @@ unspecified.


This attribute sets a specific line-ending style to be used in the 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 normalization without any
content checks, similar to setting the `crlf` attribute. content checks, similar to setting the `text` attribute.


Set to string value "crlf":: Set to string value "crlf"::


This setting forces git to normalize line endings on checkin This setting forces git to normalize line endings on checkin
and convert them to CRLF when the file is checked out, and convert them to CRLF when the file is checked out,
regardless of `crlf` and `core.autocrlf`. regardless of `text` and `core.autocrlf`.


Set to string value "lf":: Set to string value "lf"::


This setting forces git to normalize line endings to LF on This setting forces git to normalize line endings to LF on
checkin and prevents conversion to CRLF when the file is checkin and prevents conversion to CRLF when the file is
checked out, regardless of `crlf` and `core.autocrlf`. checked out, regardless of `text` and `core.autocrlf`.
`crlf=input` is a backwards compatibility alias for `eol=lf`.
Backwards compatibility with `crlf` attribute
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

For backwards compatibility, the `crlf` attribute is interpreted as
follows:

------------------------
crlf text
-crlf -text
crlf=input eol=lf
------------------------


End-of-line conversion End-of-line conversion
^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
@ -160,10 +171,10 @@ the working directory, and prevent .jpg files from being normalized
regardless of their content. regardless of their content.


------------------------ ------------------------
*.txt crlf *.txt text
*.vcproj eol=crlf *.vcproj eol=crlf
*.sh eol=lf *.sh eol=lf
*.jpg -crlf *.jpg -text
------------------------ ------------------------


Other source code management systems normalize all text files in their Other source code management systems normalize all text files in their
@ -188,24 +199,24 @@ files without conversion to CRLF in the working directory.


If you want to interoperate with a source code management system that If you want to interoperate with a source code management system that
enforces end-of-line normalization, or you simply want all text files enforces end-of-line normalization, or you simply want all text files
in your repository to be normalized, you should instead set the `crlf` in your repository to be normalized, you should instead set the `text`
attribute to "auto" for _all_ files. attribute to "auto" for _all_ files.


------------------------ ------------------------
* crlf=auto * text=auto
------------------------ ------------------------


This ensures that all files that git considers to be text will have This ensures that all files that git considers to be text will have
normalized (LF) line endings in the repository. normalized (LF) line endings in the repository.


NOTE: When `crlf=auto` normalization is enabled in an existing NOTE: When `text=auto` normalization is enabled in an existing
repository, any text files containing CRLFs should be normalized. If repository, any text files containing CRLFs should be normalized. If
they are not they will be normalized the next time someone tries to they are not they will be normalized the next time someone tries to
change them, causing unfortunate misattribution. From a clean working change them, causing unfortunate misattribution. From a clean working
directory: directory:


------------------------------------------------- -------------------------------------------------
$ echo "* crlf=auto" >>.gitattributes $ echo "* text=auto" >>.gitattributes
$ rm .git/index # Remove the index to force git to $ rm .git/index # Remove the index to force git to
$ git reset # re-scan the working directory $ git reset # re-scan the working directory
$ git status # Show files that will be normalized $ git status # Show files that will be normalized
@ -215,17 +226,17 @@ $ git commit -m "Introduce end-of-line normalization"
------------------------------------------------- -------------------------------------------------


If any files that should not be normalized show up in 'git status', If any files that should not be normalized show up in 'git status',
unset their `crlf` attribute before running 'git add -u'. unset their `text` attribute before running 'git add -u'.


------------------------ ------------------------
manual.pdf -crlf manual.pdf -text
------------------------ ------------------------


Conversely, text files that git does not detect can have normalization Conversely, text files that git does not detect can have normalization
enabled manually. enabled manually.


------------------------ ------------------------
weirdchars.txt crlf weirdchars.txt text
------------------------ ------------------------


If `core.safecrlf` is set to "true" or "warn", git verifies if If `core.safecrlf` is set to "true" or "warn", git verifies if
@ -311,11 +322,11 @@ Interaction between checkin/checkout attributes
In the check-in codepath, the worktree file is first converted In the check-in codepath, the worktree file is first converted
with `filter` driver (if specified and corresponding driver with `filter` driver (if specified and corresponding driver
defined), then the result is processed with `ident` (if defined), then the result is processed with `ident` (if
specified), and then finally with `crlf` (again, if specified specified), and then finally with `text` (again, if specified
and applicable). and applicable).


In the check-out codepath, the blob content is first converted In the check-out codepath, the blob content is first converted
with `crlf`, and then `ident` and fed to `filter`. with `text`, and then `ident` and fed to `filter`.




Generating diff text Generating diff text
@ -718,7 +729,7 @@ You do not want any end-of-line conversions applied to, nor textual diffs
produced for, any binary file you track. You would need to specify e.g. produced for, any binary file you track. You would need to specify e.g.


------------ ------------
*.jpg -crlf -diff *.jpg -text -diff
------------ ------------


but that may become cumbersome, when you have many attributes. Using but that may become cumbersome, when you have many attributes. Using
@ -731,7 +742,7 @@ the same time. The system knows a built-in attribute macro, `binary`:


which is equivalent to the above. Note that the attribute macros can only which is equivalent to the above. Note that the attribute macros can only
be "Set" (see the above example that sets "binary" macro as if it were an be "Set" (see the above example that sets "binary" macro as if it were an
ordinary attribute --- setting it in turn unsets "crlf" and "diff"). ordinary attribute --- setting it in turn unsets "text" and "diff").




DEFINING ATTRIBUTE MACROS DEFINING ATTRIBUTE MACROS
@ -742,7 +753,7 @@ at the toplevel (i.e. not in any subdirectory). The built-in attribute
macro "binary" is equivalent to: macro "binary" is equivalent to:


------------ ------------
[attr]binary -diff -crlf [attr]binary -diff -text
------------ ------------





2
attr.c
Unescape View File

@ -287,7 +287,7 @@ static void free_attr_elem(struct attr_stack *e)
} }


static const char *builtin_attr[] = { static const char *builtin_attr[] = {
"[attr]binary -diff -crlf", "[attr]binary -diff -text",
NULL, NULL,
}; };



23
convert.c
Unescape View File

@ -439,12 +439,14 @@ static int read_convert_config(const char *var, const char *value, void *cb)


static void setup_convert_check(struct git_attr_check *check) static void setup_convert_check(struct git_attr_check *check)
{ {
static struct git_attr *attr_text;
static struct git_attr *attr_crlf; static struct git_attr *attr_crlf;
static struct git_attr *attr_eol; static struct git_attr *attr_eol;
static struct git_attr *attr_ident; static struct git_attr *attr_ident;
static struct git_attr *attr_filter; static struct git_attr *attr_filter;


if (!attr_crlf) { if (!attr_text) {
attr_text = git_attr("text");
attr_crlf = git_attr("crlf"); attr_crlf = git_attr("crlf");
attr_eol = git_attr("eol"); attr_eol = git_attr("eol");
attr_ident = git_attr("ident"); attr_ident = git_attr("ident");
@ -456,6 +458,7 @@ static void setup_convert_check(struct git_attr_check *check)
check[1].attr = attr_ident; check[1].attr = attr_ident;
check[2].attr = attr_filter; check[2].attr = attr_filter;
check[3].attr = attr_eol; check[3].attr = attr_eol;
check[4].attr = attr_text;
} }


static int count_ident(const char *cp, unsigned long size) static int count_ident(const char *cp, unsigned long size)
@ -651,20 +654,20 @@ static int git_path_check_ident(const char *path, struct git_attr_check *check)
return !!ATTR_TRUE(value); return !!ATTR_TRUE(value);
} }


enum action determine_action(enum action crlf_attr, enum eol eol_attr) { enum action determine_action(enum action text_attr, enum eol eol_attr) {
if (crlf_attr == CRLF_BINARY) if (text_attr == CRLF_BINARY)
return CRLF_BINARY; return CRLF_BINARY;
if (eol_attr == EOL_LF) if (eol_attr == EOL_LF)
return CRLF_INPUT; return CRLF_INPUT;
if (eol_attr == EOL_CRLF) if (eol_attr == EOL_CRLF)
return CRLF_CRLF; return CRLF_CRLF;
return crlf_attr; return text_attr;
} }


int convert_to_git(const char *path, const char *src, size_t len, int convert_to_git(const char *path, const char *src, size_t len,
struct strbuf *dst, enum safe_crlf checksafe) struct strbuf *dst, enum safe_crlf checksafe)
{ {
struct git_attr_check check[4]; struct git_attr_check check[5];
enum action action = CRLF_GUESS; enum action action = CRLF_GUESS;
enum eol eol = EOL_UNSET; enum eol eol = EOL_UNSET;
int ident = 0, ret = 0; int ident = 0, ret = 0;
@ -673,7 +676,9 @@ int convert_to_git(const char *path, const char *src, size_t len,
setup_convert_check(check); setup_convert_check(check);
if (!git_checkattr(path, ARRAY_SIZE(check), check)) { if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
struct convert_driver *drv; struct convert_driver *drv;
action = git_path_check_crlf(path, check + 0); action = git_path_check_crlf(path, check + 4);
if (action == CRLF_GUESS)
action = git_path_check_crlf(path, check + 0);
ident = git_path_check_ident(path, check + 1); ident = git_path_check_ident(path, check + 1);
drv = git_path_check_convert(path, check + 2); drv = git_path_check_convert(path, check + 2);
eol = git_path_check_eol(path, check + 3); eol = git_path_check_eol(path, check + 3);
@ -697,7 +702,7 @@ int convert_to_git(const char *path, const char *src, size_t len,


int convert_to_working_tree(const char *path, const char *src, size_t len, struct strbuf *dst) int convert_to_working_tree(const char *path, const char *src, size_t len, struct strbuf *dst)
{ {
struct git_attr_check check[4]; struct git_attr_check check[5];
enum action action = CRLF_GUESS; enum action action = CRLF_GUESS;
enum eol eol = EOL_UNSET; enum eol eol = EOL_UNSET;
int ident = 0, ret = 0; int ident = 0, ret = 0;
@ -706,7 +711,9 @@ int convert_to_working_tree(const char *path, const char *src, size_t len, struc
setup_convert_check(check); setup_convert_check(check);
if (!git_checkattr(path, ARRAY_SIZE(check), check)) { if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
struct convert_driver *drv; struct convert_driver *drv;
action = git_path_check_crlf(path, check + 0); action = git_path_check_crlf(path, check + 4);
if (action == CRLF_GUESS)
action = git_path_check_crlf(path, check + 0);
ident = git_path_check_ident(path, check + 1); ident = git_path_check_ident(path, check + 1);
drv = git_path_check_convert(path, check + 2); drv = git_path_check_convert(path, check + 2);
eol = git_path_check_eol(path, check + 3); eol = git_path_check_eol(path, check + 3);

13
git-cvsserver.perl
Unescape View File

@ -2369,15 +2369,20 @@ sub kopts_from_path
if ( defined ( $cfg->{gitcvs}{usecrlfattr} ) and if ( defined ( $cfg->{gitcvs}{usecrlfattr} ) and
$cfg->{gitcvs}{usecrlfattr} =~ /\s*(1|true|yes)\s*$/i ) $cfg->{gitcvs}{usecrlfattr} =~ /\s*(1|true|yes)\s*$/i )
{ {
my ($val) = check_attr( "crlf", $path ); my ($val) = check_attr( "text", $path );
if ( $val eq "set" ) if ( $val eq "unspecified" )
{ {
return ""; $val = check_attr( "crlf", $path );
} }
elsif ( $val eq "unset" ) if ( $val eq "unset" )
{ {
return "-kb" return "-kb"
} }
elsif ( check_attr( "eol", $path ) ne "unspecified" ||
$val eq "set" || $val eq "input" )
{
return "";
}
else else
{ {
$log->info("Unrecognized check_attr crlf $path : $val"); $log->info("Unrecognized check_attr crlf $path : $val");

21
t/t0025-crlf-auto.sh
Unescape View File

@ -41,6 +41,7 @@ test_expect_success 'default settings cause no changes' '


test_expect_success 'crlf=true causes a CRLF file to be normalized' ' test_expect_success 'crlf=true causes a CRLF file to be normalized' '


# Backwards compatibility check
rm -f .gitattributes tmp one two three && rm -f .gitattributes tmp one two three &&
echo "two crlf" > .gitattributes && echo "two crlf" > .gitattributes &&
git read-tree --reset -u HEAD && git read-tree --reset -u HEAD &&
@ -51,6 +52,18 @@ test_expect_success 'crlf=true causes a CRLF file to be normalized' '
test -n "$twodiff" test -n "$twodiff"
' '


test_expect_success 'text=true causes a CRLF file to be normalized' '

rm -f .gitattributes tmp one two three &&
echo "two text" > .gitattributes &&
git read-tree --reset -u HEAD &&

# Note, "normalized" means that git will normalize it if added
has_cr two &&
twodiff=`git diff two` &&
test -n "$twodiff"
'

test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' ' test_expect_success 'eol=crlf gives a normalized file CRLFs with autocrlf=false' '


rm -f .gitattributes tmp one two three && rm -f .gitattributes tmp one two three &&
@ -101,11 +114,11 @@ test_expect_success 'autocrlf=true does not normalize CRLF files' '
test -z "$onediff" -a -z "$twodiff" -a -z "$threediff" test -z "$onediff" -a -z "$twodiff" -a -z "$threediff"
' '


test_expect_success 'crlf=auto, autocrlf=true _does_ normalize CRLF files' ' test_expect_success 'text=auto, autocrlf=true _does_ normalize CRLF files' '


rm -f .gitattributes tmp one two three && rm -f .gitattributes tmp one two three &&
git config core.autocrlf true && git config core.autocrlf true &&
echo "* crlf=auto" > .gitattributes && echo "* text=auto" > .gitattributes &&
git read-tree --reset -u HEAD && git read-tree --reset -u HEAD &&


has_cr one && has_cr one &&
@ -116,11 +129,11 @@ test_expect_success 'crlf=auto, autocrlf=true _does_ normalize CRLF files' '
test -z "$onediff" -a -n "$twodiff" -a -z "$threediff" test -z "$onediff" -a -n "$twodiff" -a -z "$threediff"
' '


test_expect_success 'crlf=auto, autocrlf=true does not normalize binary files' ' test_expect_success 'text=auto, autocrlf=true does not normalize binary files' '


rm -f .gitattributes tmp one two three && rm -f .gitattributes tmp one two three &&
git config core.autocrlf true && git config core.autocrlf true &&
echo "* crlf=auto" > .gitattributes && echo "* text=auto" > .gitattributes &&
git read-tree --reset -u HEAD && git read-tree --reset -u HEAD &&


! has_cr three && ! has_cr three &&

Write Preview
Loading…
Cancel
Save