[PATCH/RFC 0/8] git-ls

[PATCH/RFC 0/8] git-ls

[Nguyễn Thái Ngọc Duy]

Last time I tried this was more than two years ago [1]. It's time for
another try and see if the community has any interest in it.

The command is straight forward, it's a ls-like version for listing
things in git. It respects $LS_COLORS and does column output like GNU
ls. "ls" shows cached entries (but no recursion), "ls -o"
show untracked files. I want ls-tree, "diff --name-only" and "diff
--name-only --cached" too, but they are not implemented yet.

WIP quality, this is to gather comments on the idea.

[1] http://thread.gmane.org/gmane.comp.version-control.git/166405

Nguyễn Thái Ngọc Duy (8):
  Import $LS_COLORS parsing code from coreutils
  ls_colors.c: a bit of document on print_color_indicator input
  ls_colors.c: enable coloring on u+x files
  ls_colors.c: new color descriptors
  ls-files: add --color to highlight based on $LS_COLORS
  ls-files: add --column
  ls-files: support --max-depth
  Add git-ls, a user friendly version of ls-files and more

 Makefile           |   1 +
 builtin.h          |   1 +
 builtin/ls-files.c |  80 ++++++++-
 git.c              |   1 +
 ls_colors.c (new)  | 487 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 ls_colors.h (new)  |  20 +++
 6 files changed, 588 insertions(+), 2 deletions(-)
 create mode 100644 ls_colors.c
 create mode 100644 ls_colors.h

-- 
1.9.0.40.gaa8c3ea

[PATCH 1/8] Import $LS_COLORS parsing code from coreutils

[Nguyễn Thái Ngọc Duy]

This could could help highlight files in ls-files or status output, or
even diff --name-only (but that's questionable).

This code is from coreutils.git commit
7326d1f1a67edf21947ae98194f98c38b6e9e527 file src/ls.c. This is the
last GPL-2 commit before coreutils turns to GPL-3.

The code is reformatted to fit Git coding style, which is more than
just adding and removing spaces. For example, "bool" is replaced with
"int", or true/false replaced with 1/0, or the use of git's error()
instead of error(3). There are also two "#if 0" to make it build with
git-compat-util.h.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Makefile          |   1 +
 ls_colors.c (new) | 477 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ls_colors.h (new) |  20 +++
 3 files changed, 498 insertions(+)
 create mode 100644 ls_colors.c
 create mode 100644 ls_colors.h

diff --git a/Makefile b/Makefile
index f818eec..f6a6e14 100644
--- a/Makefile
+++ b/Makefile
@@ -819,6 +819,7 @@ LIB_OBJS += list-objects.o
 LIB_OBJS += ll-merge.o
 LIB_OBJS += lockfile.o
 LIB_OBJS += log-tree.o
+LIB_OBJS += ls_colors.o
 LIB_OBJS += mailmap.o
 LIB_OBJS += match-trees.o
 LIB_OBJS += merge.o
diff --git a/ls_colors.c b/ls_colors.c
new file mode 100644
index 0000000..6385446
--- /dev/null
+++ b/ls_colors.c
@@ -0,0 +1,477 @@
+#include "git-compat-util.h"
+#include "gettext.h"
+#include "ls_colors.h"
+
+#define STREQ(a, b) (strcmp(a, b) == 0)
+
+enum indicator_no {
+	C_LEFT, C_RIGHT, C_END, C_NORM, C_FILE, C_DIR, C_LINK, C_FIFO, C_SOCK,
+	C_BLK, C_CHR, C_MISSING, C_ORPHAN, C_EXEC, C_DOOR, C_SETUID, C_SETGID,
+	C_STICKY, C_OTHER_WRITABLE, C_STICKY_OTHER_WRITABLE
+};
+
+#define FILETYPE_INDICATORS				\
+  {							\
+    C_ORPHAN, C_FIFO, C_CHR, C_DIR, C_BLK, C_FILE,	\
+    C_LINK, C_SOCK, C_FILE, C_DIR			\
+  }
+
+struct bin_str {
+	size_t len;			/* Number of bytes */
+	const char *string;		/* Pointer to the same */
+};
+
+struct color_ext_type {
+	struct bin_str ext;		/* The extension we're looking for */
+	struct bin_str seq;		/* The sequence to output when we do */
+	struct color_ext_type *next;	/* Next in list */
+};
+
+static const char *const indicator_name[]= {
+	"lc", "rc", "ec", "no", "fi", "di", "ln", "pi", "so",
+	"bd", "cd", "mi", "or", "ex", "do", "su", "sg", "st",
+	"ow", "tw", NULL
+};
+
+#define LEN_STR_PAIR(s) sizeof(s) - 1, s
+static struct bin_str color_indicator[] = {
+	{ LEN_STR_PAIR("\033[") },	/* lc: Left of color sequence */
+	{ LEN_STR_PAIR("m") },		/* rc: Right of color sequence */
+	{ 0, NULL },			/* ec: End color (replaces lc+no+rc) */
+	{ LEN_STR_PAIR("0") },		/* no: Normal */
+	{ LEN_STR_PAIR("0") },		/* fi: File: default */
+	{ LEN_STR_PAIR("01;34") },	/* di: Directory: bright blue */
+	{ LEN_STR_PAIR("01;36") },	/* ln: Symlink: bright cyan */
+	{ LEN_STR_PAIR("33") },		/* pi: Pipe: yellow/brown */
+	{ LEN_STR_PAIR("01;35") },	/* so: Socket: bright magenta */
+	{ LEN_STR_PAIR("01;33") },	/* bd: Block device: bright yellow */
+	{ LEN_STR_PAIR("01;33") },	/* cd: Char device: bright yellow */
+	{ 0, NULL },			/* mi: Missing file: undefined */
+	{ 0, NULL },			/* or: Orphaned symlink: undefined */
+	{ LEN_STR_PAIR("01;32") },	/* ex: Executable: bright green */
+	{ LEN_STR_PAIR("01;35") },	/* do: Door: bright magenta */
+	{ LEN_STR_PAIR("37;41") },	/* su: setuid: white on red */
+	{ LEN_STR_PAIR("30;43") },	/* sg: setgid: black on yellow */
+	{ LEN_STR_PAIR("37;44") },	/* st: sticky: black on blue */
+	{ LEN_STR_PAIR("34;42") },	/* ow: other-writable: blue on green */
+	{ LEN_STR_PAIR("30;42") },	/* tw: ow w/ sticky: black on green */
+};
+
+static struct color_ext_type *color_ext_list = NULL;
+/* Buffer for color sequences */
+static char *color_buf;
+
+/*
+ * True means use colors to mark types.  Also define the different
+ * colors as well as the stuff for the LS_COLORS environment variable.
+ * The LS_COLORS variable is now in a termcap-like format.
+ */
+static int print_with_color;
+
+/*
+ * When true, in a color listing, color each symlink name according to the
+ * type of file it points to.  Otherwise, color them according to the `ln'
+ * directive in LS_COLORS.  Dangling (orphan) symlinks are treated specially,
+ * regardless.  This is set when `ln=target' appears in LS_COLORS.
+ */
+static int color_symlink_as_referent;
+
+/*
+ * Parse a string as part of the LS_COLORS variable; this may involve
+ * decoding all kinds of escape characters.  If equals_end is set an
+ * unescaped equal sign ends the string, otherwise only a : or \0
+ * does.  Set *OUTPUT_COUNT to the number of bytes output.  Return
+ * true if successful.
+ *
+ * The resulting string is *not* null-terminated, but may contain
+ * embedded nulls.
+ *
+ * Note that both dest and src are char **; on return they point to
+ * the first free byte after the array and the character that ended
+ * the input string, respectively.
+ */
+static int get_funky_string(char **dest, const char **src, int equals_end,
+			    size_t *output_count)
+{
+	char num;			/* For numerical codes */
+	size_t count;			/* Something to count with */
+	enum {
+		ST_GND, ST_BACKSLASH, ST_OCTAL, ST_HEX,
+		ST_CARET, ST_END, ST_ERROR
+	} state;
+	const char *p;
+	char *q;
+
+	p = *src;			/* We don't want to double-indirect */
+	q = *dest;			/* the whole darn time.  */
+
+	count = 0;			/* No characters counted in yet.  */
+	num = 0;
+
+	state = ST_GND;		/* Start in ground state.  */
+	while (state < ST_END) {
+		switch (state) {
+		case ST_GND:		/* Ground state (no escapes) */
+			switch (*p) {
+			case ':':
+			case '\0':
+				state = ST_END;	/* End of string */
+				break;
+			case '\\':
+				state = ST_BACKSLASH; /* Backslash scape sequence */
+				++p;
+				break;
+			case '^':
+				state = ST_CARET; /* Caret escape */
+				++p;
+				break;
+			case '=':
+				if (equals_end) {
+					state = ST_END; /* End */
+					break;
+				}
+				/* else fall through */
+			default:
+				*(q++) = *(p++);
+				++count;
+				break;
+			}
+			break;
+
+		case ST_BACKSLASH:	/* Backslash escaped character */
+			switch (*p) {
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+				state = ST_OCTAL;	/* Octal sequence */
+				num = *p - '0';
+				break;
+			case 'x':
+			case 'X':
+				state = ST_HEX;	/* Hex sequence */
+				num = 0;
+				break;
+			case 'a':		/* Bell */
+				num = '\a';
+				break;
+			case 'b':		/* Backspace */
+				num = '\b';
+				break;
+			case 'e':		/* Escape */
+				num = 27;
+				break;
+			case 'f':		/* Form feed */
+				num = '\f';
+				break;
+			case 'n':		/* Newline */
+				num = '\n';
+				break;
+			case 'r':		/* Carriage return */
+				num = '\r';
+				break;
+			case 't':		/* Tab */
+				num = '\t';
+				break;
+			case 'v':		/* Vtab */
+				num = '\v';
+				break;
+			case '?':		/* Delete */
+				num = 127;
+				break;
+			case '_':		/* Space */
+				num = ' ';
+				break;
+			case '\0':		/* End of string */
+				state = ST_ERROR;	/* Error! */
+				break;
+			default:		/* Escaped character like \ ^ : = */
+				num = *p;
+				break;
+			}
+			if (state == ST_BACKSLASH) {
+				*(q++) = num;
+				++count;
+				state = ST_GND;
+			}
+			++p;
+			break;
+
+		case ST_OCTAL:		/* Octal sequence */
+			if (*p < '0' || *p > '7') {
+				*(q++) = num;
+				++count;
+				state = ST_GND;
+			} else
+				num = (num << 3) + (*(p++) - '0');
+			break;
+
+		case ST_HEX:		/* Hex sequence */
+			switch (*p) {
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+			case '8':
+			case '9':
+				num = (num << 4) + (*(p++) - '0');
+				break;
+			case 'a':
+			case 'b':
+			case 'c':
+			case 'd':
+			case 'e':
+			case 'f':
+				num = (num << 4) + (*(p++) - 'a') + 10;
+				break;
+			case 'A':
+			case 'B':
+			case 'C':
+			case 'D':
+			case 'E':
+			case 'F':
+				num = (num << 4) + (*(p++) - 'A') + 10;
+				break;
+			default:
+				*(q++) = num;
+				++count;
+				state = ST_GND;
+				break;
+			}
+			break;
+
+		case ST_CARET:		/* Caret escape */
+			state = ST_GND;	/* Should be the next state... */
+			if (*p >= '@' && *p <= '~') {
+				*(q++) = *(p++) & 037;
+				++count;
+			} else if (*p == '?') {
+				*(q++) = 127;
+				++count;
+			} else
+				state = ST_ERROR;
+			break;
+
+		default:
+			abort();
+		}
+	}
+
+	*dest = q;
+	*src = p;
+	*output_count = count;
+
+	return state != ST_ERROR;
+}
+
+void parse_ls_color(void)
+{
+	const char *p;			/* Pointer to character being parsed */
+	char *buf;			/* color_buf buffer pointer */
+	int state;			/* State of parser */
+	int ind_no;			/* Indicator number */
+	char label[3];			/* Indicator label */
+	struct color_ext_type *ext;	/* Extension we are working on */
+
+	if ((p = getenv("LS_COLORS")) == NULL || *p == '\0')
+		return;
+
+	ext = NULL;
+	strcpy (label, "??");
+
+	/*
+	 * This is an overly conservative estimate, but any possible
+	 * LS_COLORS string will *not* generate a color_buf longer
+	 * than itself, so it is a safe way of allocating a buffer in
+	 * advance.
+	 */
+	buf = color_buf = xstrdup(p);
+
+	state = 1;
+	while (state > 0) {
+		switch (state) {
+		case 1:		/* First label character */
+			switch (*p) {
+			case ':':
+				++p;
+				break;
+
+			case '*':
+				/*
+				 * Allocate new extension block and add to head of
+				 * linked list (this way a later definition will
+				 * override an earlier one, which can be useful for
+				 * having terminal-specific defs override global).
+				 */
+
+				ext = xmalloc(sizeof *ext);
+				ext->next = color_ext_list;
+				color_ext_list = ext;
+
+				++p;
+				ext->ext.string = buf;
+
+				state = (get_funky_string(&buf, &p, 1, &ext->ext.len)
+					 ? 4 : -1);
+				break;
+
+			case '\0':
+				state = 0;	/* Done! */
+				break;
+
+			default:	/* Assume it is file type label */
+				label[0] = *(p++);
+				state = 2;
+				break;
+			}
+			break;
+
+		case 2:		/* Second label character */
+			if (*p) {
+				label[1] = *(p++);
+				state = 3;
+			} else
+				state = -1;	/* Error */
+			break;
+
+		case 3:		/* Equal sign after indicator label */
+			state = -1;	/* Assume failure...  */
+			if (*(p++) == '=') { /* It *should* be...  */
+				for (ind_no = 0; indicator_name[ind_no] != NULL; ++ind_no) {
+					if (STREQ (label, indicator_name[ind_no])) {
+						color_indicator[ind_no].string = buf;
+						state = (get_funky_string(&buf, &p, 0,
+									  &color_indicator[ind_no].len)
+							 ? 1 : -1);
+						break;
+					}
+				}
+				if (state == -1)
+					error(_("unrecognized prefix: %s"), label);
+			}
+			break;
+
+		case 4:		/* Equal sign after *.ext */
+			if (*(p++) == '=') {
+				ext->seq.string = buf;
+				state = (get_funky_string(&buf, &p, 0, &ext->seq.len)
+					 ? 1 : -1);
+			} else
+				state = -1;
+			break;
+		}
+	}
+
+	if (state < 0) {
+		struct color_ext_type *e;
+		struct color_ext_type *e2;
+
+		error(_("unparsable value for LS_COLORS environment variable"));
+		free(color_buf);
+		for (e = color_ext_list; e != NULL; /* empty */) {
+			e2 = e;
+			e = e->next;
+			free(e2);
+		}
+		print_with_color = 0;
+	}
+
+	if (color_indicator[C_LINK].len == 6 &&
+	    !strncmp(color_indicator[C_LINK].string, "target", 6))
+		color_symlink_as_referent = 1;
+}
+
+/* Output a color indicator (which may contain nulls).  */
+static void put_indicator(const struct bin_str *ind)
+{
+	size_t i;
+	const char *p;
+
+	p = ind->string;
+
+	for (i = ind->len; i != 0; --i)
+		putchar(*(p++));
+}
+
+void print_color_indicator(const char *name, mode_t mode, int linkok,
+			   int stat_ok, enum filetype filetype)
+{
+	int type;
+	struct color_ext_type *ext;	/* Color extension */
+	size_t len;			/* Length of name */
+
+	/* Is this a nonexistent file?  If so, linkok == -1.  */
+
+	if (linkok == -1 && color_indicator[C_MISSING].string != NULL)
+		type = C_MISSING;
+	else if (!stat_ok) {
+		static enum indicator_no filetype_indicator[] = FILETYPE_INDICATORS;
+		type = filetype_indicator[filetype];
+	} else {
+		if (S_ISREG(mode)) {
+			type = C_FILE;
+			if ((mode & S_ISUID) != 0)
+				type = C_SETUID;
+			else if ((mode & S_ISGID) != 0)
+				type = C_SETGID;
+#if 0
+			else if ((mode & S_IXUGO) != 0)
+				type = C_EXEC;
+#endif
+		} else if (S_ISDIR(mode)) {
+			if ((mode & S_ISVTX) && (mode & S_IWOTH))
+				type = C_STICKY_OTHER_WRITABLE;
+			else if ((mode & S_IWOTH) != 0)
+				type = C_OTHER_WRITABLE;
+			else if ((mode & S_ISVTX) != 0)
+				type = C_STICKY;
+			else
+				type = C_DIR;
+		} else if (S_ISLNK(mode))
+			type = ((!linkok && color_indicator[C_ORPHAN].string)
+				? C_ORPHAN : C_LINK);
+		else if (S_ISFIFO(mode))
+			type = C_FIFO;
+		else if (S_ISSOCK(mode))
+			type = C_SOCK;
+		else if (S_ISBLK(mode))
+			type = C_BLK;
+		else if (S_ISCHR(mode))
+			type = C_CHR;
+#if 0
+		else if (S_ISDOOR(mode))
+			type = C_DOOR;
+#endif
+		else {
+			/* Classify a file of some other type as C_ORPHAN.  */
+			type = C_ORPHAN;
+		}
+	}
+
+	/* Check the file's suffix only if still classified as C_FILE.  */
+	ext = NULL;
+	if (type == C_FILE) {
+		/* Test if NAME has a recognized suffix.  */
+
+		len = strlen(name);
+		name += len;		/* Pointer to final \0.  */
+		for (ext = color_ext_list; ext != NULL; ext = ext->next) {
+			if (ext->ext.len <= len
+			    && strncmp(name - ext->ext.len, ext->ext.string,
+				       ext->ext.len) == 0)
+				break;
+		}
+	}
+
+	put_indicator(&color_indicator[C_LEFT]);
+	put_indicator(ext ? &(ext->seq) : &color_indicator[type]);
+	put_indicator(&color_indicator[C_RIGHT]);
+}
diff --git a/ls_colors.h b/ls_colors.h
new file mode 100644
index 0000000..3201be6
--- /dev/null
+++ b/ls_colors.h
@@ -0,0 +1,20 @@
+#ifndef LS_COLORS_H
+#define LS_COLORS_H
+
+enum filetype {
+	unknown,
+	fifo,
+	chardev,
+	directory,
+	blockdev,
+	normal,
+	symbolic_link,
+	sock,
+	whiteout,
+	arg_directory
+};
+
+void parse_ls_color(void);
+void print_color_indicator(const char *name, mode_t mode, int linkok,
+			   int stat_ok, enum filetype filetype);
+#endif
-- 
1.9.0.40.gaa8c3ea

[PATCH 2/8] ls_colors.c: a bit of document on print_color_indicator input

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 ls_colors.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/ls_colors.c b/ls_colors.c
index 6385446..d492ab3 100644
--- a/ls_colors.c
+++ b/ls_colors.c
@@ -401,6 +401,11 @@ static void put_indicator(const struct bin_str *ind)
 		putchar(*(p++));
 }
 
+/*
+ * mode is only used if stat_ok is true, else filetype is used. if
+ * linkok is -1, shows broken link. If linkok is zero and mode says
+ * it's a link, then show orphan link.
+ */
 void print_color_indicator(const char *name, mode_t mode, int linkok,
 			   int stat_ok, enum filetype filetype)
 {
-- 
1.9.0.40.gaa8c3ea

[PATCH 3/8] ls_colors.c: enable coloring on u+x files

[Nguyễn Thái Ngọc Duy]

git-compat-util.h does not seem to carry S_IXUGO. Anyway as far as Git
is concerned, we only care one executable bit. Hard code it.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 ls_colors.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/ls_colors.c b/ls_colors.c
index d492ab3..23f1e0b 100644
--- a/ls_colors.c
+++ b/ls_colors.c
@@ -427,10 +427,8 @@ void print_color_indicator(const char *name, mode_t mode, int linkok,
 				type = C_SETUID;
 			else if ((mode & S_ISGID) != 0)
 				type = C_SETGID;
-#if 0
-			else if ((mode & S_IXUGO) != 0)
+			else if ((mode & 0100) != 0)
 				type = C_EXEC;
-#endif
 		} else if (S_ISDIR(mode)) {
 			if ((mode & S_ISVTX) && (mode & S_IWOTH))
 				type = C_STICKY_OTHER_WRITABLE;
-- 
1.9.0.40.gaa8c3ea

[PATCH 4/8] ls_colors.c: new color descriptors

[Nguyễn Thái Ngọc Duy]

After coreutils moved to GPL-3 a couple more color descriptors were
added. parse_ls_color() will abort if it finds any of these so just
add them recognized (but never actually use them).

Reference commits (in coreutils.git)

0df338f (ls --color: do not colorize files with multiple hard links by default - 2009-06-10)
adc62b5 (ls: clean up after wrapped+colored file names with clear-to-EOL - 2008-12-31)
1e48b1f (ls: --color now highlights hard linked files, too - 2008-10-27)
84f6abf (ls: --color now highlights files with capabilities, too - 2008-08-01)
483297d (ls --color no longer outputs unnecessary escape sequences - 2008-02-12)

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 ls_colors.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/ls_colors.c b/ls_colors.c
index 23f1e0b..02fc632 100644
--- a/ls_colors.c
+++ b/ls_colors.c
@@ -5,9 +5,12 @@
 #define STREQ(a, b) (strcmp(a, b) == 0)
 
 enum indicator_no {
-	C_LEFT, C_RIGHT, C_END, C_NORM, C_FILE, C_DIR, C_LINK, C_FIFO, C_SOCK,
+	C_LEFT, C_RIGHT, C_END, C_RESET, C_NORM,
+	C_FILE, C_DIR, C_LINK, C_FIFO, C_SOCK,
 	C_BLK, C_CHR, C_MISSING, C_ORPHAN, C_EXEC, C_DOOR, C_SETUID, C_SETGID,
-	C_STICKY, C_OTHER_WRITABLE, C_STICKY_OTHER_WRITABLE
+	C_STICKY, C_OTHER_WRITABLE, C_STICKY_OTHER_WRITABLE,
+	C_CAP, C_MULTIHARDLINK, C_CLR_TO_EOL
+
 };
 
 #define FILETYPE_INDICATORS				\
@@ -28,9 +31,9 @@ struct color_ext_type {
 };
 
 static const char *const indicator_name[]= {
-	"lc", "rc", "ec", "no", "fi", "di", "ln", "pi", "so",
+	"lc", "rc", "ec", "rs", "no", "fi", "di", "ln", "pi", "so",
 	"bd", "cd", "mi", "or", "ex", "do", "su", "sg", "st",
-	"ow", "tw", NULL
+	"ow", "tw", "ca", "mh", "cl", NULL
 };
 
 #define LEN_STR_PAIR(s) sizeof(s) - 1, s
@@ -38,6 +41,7 @@ static struct bin_str color_indicator[] = {
 	{ LEN_STR_PAIR("\033[") },	/* lc: Left of color sequence */
 	{ LEN_STR_PAIR("m") },		/* rc: Right of color sequence */
 	{ 0, NULL },			/* ec: End color (replaces lc+no+rc) */
+	{ 0, NULL },			/* rs: Reset to ordinary colors */
 	{ LEN_STR_PAIR("0") },		/* no: Normal */
 	{ LEN_STR_PAIR("0") },		/* fi: File: default */
 	{ LEN_STR_PAIR("01;34") },	/* di: Directory: bright blue */
@@ -55,6 +59,9 @@ static struct bin_str color_indicator[] = {
 	{ LEN_STR_PAIR("37;44") },	/* st: sticky: black on blue */
 	{ LEN_STR_PAIR("34;42") },	/* ow: other-writable: blue on green */
 	{ LEN_STR_PAIR("30;42") },	/* tw: ow w/ sticky: black on green */
+	{ 0, NULL },			/* ca: black on red */
+	{ 0, NULL },			/* mh: disabled by default */
+	{ 0, NULL },			/* cl: clear to end of line */
 };
 
 static struct color_ext_type *color_ext_list = NULL;
-- 
1.9.0.40.gaa8c3ea

[PATCH 5/8] ls-files: add --color to highlight based on $LS_COLORS

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 38 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 36 insertions(+), 2 deletions(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 47c3880..463280e 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -14,6 +14,8 @@
 #include "resolve-undo.h"
 #include "string-list.h"
 #include "pathspec.h"
+#include "color.h"
+#include "ls_colors.h"
 
 static int abbrev;
 static int show_deleted;
@@ -27,6 +29,7 @@ static int show_killed;
 static int show_valid_bit;
 static int line_terminator = '\n';
 static int debug_mode;
+static int use_color;
 
 static const char *prefix;
 static int max_prefix_len;
@@ -57,6 +60,33 @@ static void write_name(const char *name)
 				   stdout, line_terminator);
 }
 
+static void write_dir_entry(const struct dir_entry *ent)
+{
+	if (want_color(use_color)) {
+		static struct strbuf sb = STRBUF_INIT;
+		struct stat st;
+		int statok;
+		quote_path_relative(ent->name, prefix_len ? prefix : NULL, &sb);
+		statok = stat(ent->name, &st) == 0;
+		print_color_indicator(sb.buf, st.st_mode, 0, statok, 0);
+		fputs(sb.buf, stdout);
+		printf("%s%c", GIT_COLOR_RESET, line_terminator);
+	} else
+		write_name(ent->name);
+}
+
+static void write_ce_name(const struct cache_entry *ce)
+{
+	if (want_color(use_color)) {
+		static struct strbuf sb = STRBUF_INIT;
+		quote_path_relative(ce->name, prefix_len ? prefix : NULL, &sb);
+		print_color_indicator(sb.buf, ce->ce_mode, 1, 1, 0);
+		fputs(sb.buf, stdout);
+		printf("%s%c", GIT_COLOR_RESET, line_terminator);
+	} else
+		write_name(ce->name);
+}
+
 static void show_dir_entry(const char *tag, struct dir_entry *ent)
 {
 	int len = max_prefix_len;
@@ -68,7 +98,7 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
 		return;
 
 	fputs(tag, stdout);
-	write_name(ent->name);
+	write_dir_entry(ent);
 }
 
 static void show_other_files(struct dir_struct *dir)
@@ -170,7 +200,7 @@ static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 		       find_unique_abbrev(ce->sha1,abbrev),
 		       ce_stage(ce));
 	}
-	write_name(ce->name);
+	write_ce_name(ce);
 	if (debug_mode) {
 		const struct stat_data *sd = &ce->ce_stat_data;
 
@@ -501,6 +531,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			N_("if any <file> is not in the index, treat this as an error")),
 		OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
 			N_("pretend that paths removed since <tree-ish> are still present")),
+		OPT__COLOR(&use_color, N_("show color")),
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -548,6 +579,9 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	if (require_work_tree && !is_inside_work_tree())
 		setup_work_tree();
 
+	if (want_color(use_color))
+		parse_ls_color();
+
 	parse_pathspec(&pathspec, 0,
 		       PATHSPEC_PREFER_CWD |
 		       PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
-- 
1.9.0.40.gaa8c3ea

[PATCH 6/8] ls-files: add --column

[Nguyễn Thái Ngọc Duy]

Default pathspec behavior is recursive which includes too many files
for effective column output. But if you can do

git ls-files --column ':(glob)*'

to limit to one level only. It's not exactly the same as GNU ls
(e.g. directories are never shown) but much closer.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 463280e..a43abdb 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -16,6 +16,7 @@
 #include "pathspec.h"
 #include "color.h"
 #include "ls_colors.h"
+#include "column.h"
 
 static int abbrev;
 static int show_deleted;
@@ -476,6 +477,7 @@ static int option_parse_exclude_standard(const struct option *opt,
 int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 {
 	int require_work_tree = 0, show_tag = 0, i;
+	unsigned int colopts = 0;
 	const char *max_prefix;
 	struct dir_struct dir;
 	struct exclude_list *el;
@@ -532,6 +534,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
 			N_("pretend that paths removed since <tree-ish> are still present")),
 		OPT__COLOR(&use_color, N_("show color")),
+		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -576,6 +579,10 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	if (dir.exclude_per_dir)
 		exc_given = 1;
 
+	finalize_colopts(&colopts, -1);
+	if (!line_terminator && explicitly_enable_column(colopts))
+		die(_("--column and -z are incompatible"));
+
 	if (require_work_tree && !is_inside_work_tree())
 		setup_work_tree();
 
@@ -614,10 +621,19 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			die("ls-files --with-tree is incompatible with -s or -u");
 		overlay_tree_on_cache(with_tree, max_prefix);
 	}
+
+	if (column_active(colopts)) {
+		struct column_options copts;
+		memset(&copts, 0, sizeof(copts));
+		run_column_filter(colopts, &copts);
+	}
 	show_files(&dir);
 	if (show_resolve_undo)
 		show_ru_info();
 
+	if (column_active(colopts))
+		stop_column_filter();
+
 	if (ps_matched) {
 		int bad;
 		bad = report_path_error(ps_matched, &pathspec, prefix);
-- 
1.9.0.40.gaa8c3ea

[PATCH 7/8] ls-files: support --max-depth

[Nguyễn Thái Ngọc Duy]

The use case in mind is --max-depth=0 to stop recursion. With this we can do

git config --global alias.ls 'ls-files --column --color --max-depth=0'

and have "git ls" with an output very similar to GNU ls. Another
interesting one is

git config --global alias.lso 'ls-files --column --color --max-depth=0 -o --exclude-standard'

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index a43abdb..2c51b0a 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -478,6 +478,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 {
 	int require_work_tree = 0, show_tag = 0, i;
 	unsigned int colopts = 0;
+	int max_depth = -1;
 	const char *max_prefix;
 	struct dir_struct dir;
 	struct exclude_list *el;
@@ -535,6 +536,9 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			N_("pretend that paths removed since <tree-ish> are still present")),
 		OPT__COLOR(&use_color, N_("show color")),
 		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
+		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
+			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
+			NULL, 1 },
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -591,8 +595,11 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 
 	parse_pathspec(&pathspec, 0,
 		       PATHSPEC_PREFER_CWD |
+		       (max_depth != -1 ? PATHSPEC_MAXDEPTH_VALID : 0) |
 		       PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
 		       prefix, argv);
+	pathspec.max_depth = max_depth;
+	pathspec.recursive = 1;
 
 	/* Find common prefix for all pathspec's */
 	max_prefix = common_prefix(&pathspec);
-- 
1.9.0.40.gaa8c3ea

[PATCH 8/8] Add git-ls, a user friendly version of ls-files and more

[Nguyễn Thái Ngọc Duy]

For now it's simply a wrapper of ls-files with some default
goodies. But I want it to be the UI for ls-tree and perhaps git diff
--name-only [--cached] too.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin.h          |  1 +
 builtin/ls-files.c | 19 +++++++++++++++++++
 git.c              |  1 +
 3 files changed, 21 insertions(+)

diff --git a/builtin.h b/builtin.h
index c47c110..177aa7d 100644
--- a/builtin.h
+++ b/builtin.h
@@ -75,6 +75,7 @@ extern int cmd_index_pack(int argc, const char **argv, const char *prefix);
 extern int cmd_init_db(int argc, const char **argv, const char *prefix);
 extern int cmd_log(int argc, const char **argv, const char *prefix);
 extern int cmd_log_reflog(int argc, const char **argv, const char *prefix);
+extern int cmd_ls(int argc, const char **argv, const char *prefix);
 extern int cmd_ls_files(int argc, const char **argv, const char *prefix);
 extern int cmd_ls_tree(int argc, const char **argv, const char *prefix);
 extern int cmd_ls_remote(int argc, const char **argv, const char *prefix);
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 2c51b0a..5354339 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -17,6 +17,7 @@
 #include "color.h"
 #include "ls_colors.h"
 #include "column.h"
+#include "argv-array.h"
 
 static int abbrev;
 static int show_deleted;
@@ -479,6 +480,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	int require_work_tree = 0, show_tag = 0, i;
 	unsigned int colopts = 0;
 	int max_depth = -1;
+	int refresh = 0;
 	const char *max_prefix;
 	struct dir_struct dir;
 	struct exclude_list *el;
@@ -539,6 +541,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
 			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
 			NULL, 1 },
+		OPT_HIDDEN_BOOL(0, "refresh-index", &refresh, N_("refresh index")),
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -555,6 +558,8 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 
 	if (read_cache() < 0)
 		die("index file corrupt");
+	if (refresh)
+		refresh_cache(REFRESH_QUIET);
 
 	argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
 			ls_files_usage, 0);
@@ -652,3 +657,17 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 
 	return 0;
 }
+
+int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
+{
+	struct argv_array av = ARGV_ARRAY_INIT;
+	argv_array_pushl(&av, "ls-files",
+			 "--color", "--column", "--max-depth=0",
+			 "--exclude-standard", "--refresh-index",
+			 NULL);
+	argv++;
+	while (*argv)
+		argv_array_push(&av, *argv++);
+	trace_argv_printf(av.argv, "trace: built-in: git");
+	return cmd_ls_files(av.argc, av.argv, cmd_prefix);
+}
diff --git a/git.c b/git.c
index 9efd1a3..682a81e 100644
--- a/git.c
+++ b/git.c
@@ -381,6 +381,7 @@ static struct cmd_struct commands[] = {
 	{ "init", cmd_init_db },
 	{ "init-db", cmd_init_db },
 	{ "log", cmd_log, RUN_SETUP },
+	{ "ls", cmd_ls, RUN_SETUP },
 	{ "ls-files", cmd_ls_files, RUN_SETUP },
 	{ "ls-remote", cmd_ls_remote, RUN_SETUP_GENTLY },
 	{ "ls-tree", cmd_ls_tree, RUN_SETUP },
-- 
1.9.0.40.gaa8c3ea

Re: [PATCH 3/8] ls_colors.c: enable coloring on u+x files

[Matthieu Moy]

Nguyễn Thái Ngọc Duy <pclouds@gmail.com> writes:

> git-compat-util.h does not seem to carry S_IXUGO. Anyway as far as Git
> is concerned, we only care one executable bit. Hard code it.

Why not use S_IXUSR instead of a hardcoded value? (already used in
path.c, so shouldn't be a problem wrt portability)

-- 
Matthieu Moy
http://www-verimag.imag.fr/~moy/

Re: [PATCH 8/8] Add git-ls, a user friendly version of ls-files and more

[Matthieu Moy]

Nguyễn Thái Ngọc Duy <pclouds@gmail.com> writes:

> +int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
> +{
> +	struct argv_array av = ARGV_ARRAY_INIT;
> +	argv_array_pushl(&av, "ls-files",
> +			 "--color", "--column", "--max-depth=0",
> +			 "--exclude-standard", "--refresh-index",
> +			 NULL);

I already have "git ls" as an alias for "git ls-files
--exclude-standard", so this change would bring me even more goodies, I
like it.

I'm a bit hesitant on the --max-depth=0 part by default. I like the way
my "git ls" alias recurses by default, but that may be just because I'm
used to it. Also, disabling it is can only be done by adding
--max-depth=-1 to the command-line, which isn't very convenient. Perhaps
there should be a "git ls -R" shorthand for "git ls --max-depth=-1".

-- 
Matthieu Moy
http://www-verimag.imag.fr/~moy/

Re: [PATCH 3/8] ls_colors.c: enable coloring on u+x files

[Duy Nguyen]

On Thu, Mar 20, 2014 at 6:46 PM, Matthieu Moy
<Matthieu.Moy@grenoble-inp.fr> wrote:
> Nguyễn Thái Ngọc Duy <pclouds@gmail.com> writes:
>
>> git-compat-util.h does not seem to carry S_IXUGO. Anyway as far as Git
>> is concerned, we only care one executable bit. Hard code it.
>
> Why not use S_IXUSR instead of a hardcoded value? (already used in
> path.c, so shouldn't be a problem wrt portability)

Hmm..maybe cache.h does something to that macro. Will drop this patch
and include cache.h.
-- 
Duy

Re: [PATCH 3/8] ls_colors.c: enable coloring on u+x files

[Junio C Hamano]

Duy Nguyen <pclouds@gmail.com> writes:

> On Thu, Mar 20, 2014 at 6:46 PM, Matthieu Moy
> <Matthieu.Moy@grenoble-inp.fr> wrote:
>> Nguyễn Thái Ngọc Duy <pclouds@gmail.com> writes:
>>
>>> git-compat-util.h does not seem to carry S_IXUGO. Anyway as far as Git
>>> is concerned, we only care one executable bit. Hard code it.
>>
>> Why not use S_IXUSR instead of a hardcoded value? (already used in
>> path.c, so shouldn't be a problem wrt portability)
>
> Hmm..maybe cache.h does something to that macro. Will drop this patch
> and include cache.h.

Why even include cache.h for S_IXUSR?

In the context of the patch I see S_ISGID mentioned and other S_*
st_mode things are already in use in this function before this step,
and presumably you are using them without problems, no?

Re: [PATCH 1/8] Import $LS_COLORS parsing code from coreutils

[David Tran]

Nguyễn Thái Ngọc Duy <pclouds <at> gmail.com> writes:

> This could could help highlight files in ls-files or status output, or
> even diff --name-only (but that's questionable).
> 
> This code is from coreutils.git commit
> 7326d1f1a67edf21947ae98194f98c38b6e9e527 file src/ls.c. This is the
> last GPL-2 commit before coreutils turns to GPL-3.
> 

I don't know if this is something to consider but for my mac, I have another 
variable CLICOLOR which shows the colors if it is set. This is also true with 
FreeBSD[1] as well. I don't know if that should be checked if you're on those 
systems.

I think it would be nice to have --color flag as well if you want to enable 
color output for just that one output. 

[1]: https://unix.stackexchange.com/questions/2897/clicolor-and-ls-colors-in-
bash

Re: [PATCH 3/8] ls_colors.c: enable coloring on u+x files

[Duy Nguyen]

On Fri, Mar 21, 2014 at 12:41 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Why even include cache.h for S_IXUSR?
>
> In the context of the patch I see S_ISGID mentioned and other S_*
> st_mode things are already in use in this function before this step,
> and presumably you are using them without problems, no?

My mistake. git-compat-util.h does include S_IXUSR. The original code
was S_IXUGO that's in neither files.
-- 
Duy

Re: [PATCH 1/8] Import $LS_COLORS parsing code from coreutils

[Duy Nguyen]

On Fri, Mar 21, 2014 at 2:09 AM, David Tran <unsignedzero@gmail.com> wrote:
> Nguyễn Thái Ngọc Duy <pclouds <at> gmail.com> writes:
>
>> This could could help highlight files in ls-files or status output, or
>> even diff --name-only (but that's questionable).
>>
>> This code is from coreutils.git commit
>> 7326d1f1a67edf21947ae98194f98c38b6e9e527 file src/ls.c. This is the
>> last GPL-2 commit before coreutils turns to GPL-3.
>>
>
> I don't know if this is something to consider but for my mac, I have another
> variable CLICOLOR which shows the colors if it is set. This is also true with
> FreeBSD[1] as well. I don't know if that should be checked if you're on those
> systems.
>
> I think it would be nice to have --color flag as well if you want to enable
> color output for just that one output.

My plan is stick to how git handles colors (e.g. --color and color.*
config variables). Is that enough or do you think git CLICOLOR should
override --color and color.*?

>
> [1]: https://unix.stackexchange.com/questions/2897/clicolor-and-ls-colors-in-
> bash
>
> --
> To unsubscribe from this list: send the line "unsubscribe git" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html



-- 
Duy

Re: [PATCH 1/8] Import $LS_COLORS parsing code from coreutils

[David Tran]

Duy Nguyen <pclouds <at> gmail.com> writes:

> On Fri, Mar 21, 2014 at 2:09 AM, David Tran <unsignedzero <at> gmail.com>
wrote:
> > Nguyễn Thái Ngọc Duy <pclouds <at> gmail.com> writes:
> >
> >> This could could help highlight files in ls-files or status output, or
> >> even diff --name-only (but that's questionable).
> >>
> >> This code is from coreutils.git commit
> >> 7326d1f1a67edf21947ae98194f98c38b6e9e527 file src/ls.c. This is the
> >> last GPL-2 commit before coreutils turns to GPL-3.
> >>
> >
> > I don't know if this is something to consider but for my mac, I have another
> > variable CLICOLOR which shows the colors if it is set. This is also true
with
> > FreeBSD[1] as well. I don't know if that should be checked if you're on
those
> > systems.
> >
> > I think it would be nice to have --color flag as well if you want to enable
> > color output for just that one output.
> 
> My plan is stick to how git handles colors (e.g. --color and color.*
> config variables). Is that enough or do you think git CLICOLOR should
> override --color and color.*?
> 
I would say it is not an essential feature to have but something that might
be looked into once the color is implemented. If its not set, ignore it. If
it is set, check if it is truthy, is what I would do.

Re: [PATCH 7/8] ls-files: support --max-depth

[Matthieu Moy]

----- Original Message -----
> The use case in mind is --max-depth=0 to stop recursion. With this we can do
> 
> git config --global alias.ls 'ls-files --column --color --max-depth=0'
> 
> and have "git ls" with an output very similar to GNU ls.

One big difference though: your "git ls" does not show directories. I understand that this is easier to implement, but from the user point of view it resulted in a "wtf" from me running "git ls" in a repository containing essentially directories, and seeing just a README file in the output.

Ideally (for me), directories should be shown with a trailing / like "ls -F" does.

-- 
Matthieu Moy
http://www-verimag.imag.fr/~moy/

Re: [PATCH 7/8] ls-files: support --max-depth

[Duy Nguyen]

On Tue, Mar 25, 2014 at 3:55 PM, Matthieu Moy
<matthieu.moy@grenoble-inp.fr> wrote:
> ----- Original Message -----
>> The use case in mind is --max-depth=0 to stop recursion. With this we can do
>>
>> git config --global alias.ls 'ls-files --column --color --max-depth=0'
>>
>> and have "git ls" with an output very similar to GNU ls.
>
> One big difference though: your "git ls" does not show directories. I understand that this is easier to implement, but from the user point of view it resulted in a "wtf" from me running "git ls" in a repository containing essentially directories, and seeing just a README file in the output.

I was hoping you didn't notice :) It'll be more difficult but not impossible.

> Ideally (for me), directories should be shown with a trailing / like "ls -F" does.

I'd rather go with no trailing slash by default and add -F (which
seems to be more than just '/')
-- 
Duy

Re: [PATCH 6/8] ls-files: add --column

[Matthieu Moy]

Nguyễn Thái Ngọc Duy <pclouds@gmail.com> writes:

> +		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),

To look a bit more like "ls", you could add a -1 option as an alias for
--no-column.

That would be a good idea only if there is no plan to ever add a -N
option (like "git log -42"). I don't know if any -N option could make
sense.

-- 
Matthieu Moy
http://www-verimag.imag.fr/~moy/

[PATCH v2 00/17] git-ls

[Nguyễn Thái Ngọc Duy]

Compared to v1, git-ls now does not accept ls-files options (previous
git-ls is more like an alias of ls-files). I want this because ls may
take a different set of options than ls-files. Most functionality is
shared so if you're not happy with ls, you can fall back to ls-files.

New alias options are supported, -1 == --no-column, -R ==
--max-depth=-1. If more than one file criteria is chosen (e.g. "ls -cmo")
then --tag is implied. File order is fixed ("ls-files -cmo" actually
shows two or three separate listings, "ls -cmo" shows one sorted
listing). It also shows directories from the index.

Documentation is there. No tests yet because the behavior may still
need some polishing.

Nguyễn Thái Ngọc Duy (17):
  ls_colors.c: add $LS_COLORS parsing code
  ls_colors.c: parse color.ls.* from config file
  ls_colors.c: add function to color a file name
  ls_colors.c: highlight submodules like directories
  ls-files: buffer full item in strbuf before printing
  ls-files: add --color to highlight file names
  ls-files: add --column
  ls-files: support --max-depth
  ls-files: split main ls-files logic into ls_files() function
  Add git-ls, a user friendly version of ls-files and more
  ls: -u does not imply showing stages
  ls: add -R/--recursive short for --max-depth=-1
  ls: add -1 short for --no-column in the spirit of GNU ls
  ls: add -t back
  ls: sort output and remove duplicates
  ls: do not show duplicate cached entries
  ls: show directories as well as files

 .gitignore                     |   1 +
 Documentation/config.txt       |  22 ++
 Documentation/git-ls-files.txt |  22 ++
 Documentation/git-ls.txt (new) |  95 ++++++++
 Makefile                       |   2 +
 builtin.h                      |   1 +
 builtin/ls-files.c             | 446 +++++++++++++++++++++++++++++-------
 color.h                        |  10 +
 command-list.txt               |   1 +
 git.c                          |   1 +
 ls_colors.c (new)              | 496 +++++++++++++++++++++++++++++++++++++++++
 11 files changed, 1012 insertions(+), 85 deletions(-)
 create mode 100644 Documentation/git-ls.txt
 create mode 100644 ls_colors.c

-- 
1.9.1.345.ga1a145c

[PATCH v2 01/17] ls_colors.c: add $LS_COLORS parsing code

[Nguyễn Thái Ngọc Duy]

Reusing color settings from $LS_COLORS could give a native look and
feel on file coloring.

This code is basically from coreutils.git [1], rewritten to fit Git.

As this is from GNU ls, the environment variable CLICOLOR is not
tested. It is to be decided later whether we should ignore $LS_COLORS
if $CLICOLOR is not set on Mac or FreeBSD.

[1] commit 7326d1f1a67edf21947ae98194f98c38b6e9e527 file
    src/ls.c. This is the last GPL-2 commit before coreutils turns to
    GPL-3.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Makefile          |   1 +
 color.h           |   8 ++
 ls_colors.c (new) | 398 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 407 insertions(+)
 create mode 100644 ls_colors.c

diff --git a/Makefile b/Makefile
index f818eec..f6a6e14 100644
--- a/Makefile
+++ b/Makefile
@@ -819,6 +819,7 @@ LIB_OBJS += list-objects.o
 LIB_OBJS += ll-merge.o
 LIB_OBJS += lockfile.o
 LIB_OBJS += log-tree.o
+LIB_OBJS += ls_colors.o
 LIB_OBJS += mailmap.o
 LIB_OBJS += match-trees.o
 LIB_OBJS += merge.o
diff --git a/color.h b/color.h
index 9a8495b..640fc48 100644
--- a/color.h
+++ b/color.h
@@ -45,6 +45,12 @@ struct strbuf;
 #define GIT_COLOR_BG_MAGENTA	"\033[45m"
 #define GIT_COLOR_BG_CYAN	"\033[46m"
 
+#define GIT_COLOR_WHITE_ON_RED    "\033[37;41m"
+#define GIT_COLOR_WHITE_ON_BLUE   "\033[37;44m"
+#define GIT_COLOR_BLACK_ON_YELLOW "\033[30;43m"
+#define GIT_COLOR_BLUE_ON_GREEN   "\033[34;42m"
+#define GIT_COLOR_BLACK_ON_GREEN  "\033[30;42m"
+
 /* A special value meaning "no color selected" */
 #define GIT_COLOR_NIL "NIL"
 
@@ -87,4 +93,6 @@ void color_print_strbuf(FILE *fp, const char *color, const struct strbuf *sb);
 
 int color_is_nil(const char *color);
 
+void parse_ls_color(void);
+
 #endif /* COLOR_H */
diff --git a/ls_colors.c b/ls_colors.c
new file mode 100644
index 0000000..eb944f4
--- /dev/null
+++ b/ls_colors.c
@@ -0,0 +1,398 @@
+#include "cache.h"
+#include "color.h"
+
+enum color_ls {
+	LS_LC,			/* left, unused */
+	LS_RC,			/* right, unused */
+	LS_EC,			/* end color, unused */
+	LS_RS,			/* reset */
+	LS_NO,			/* normal */
+	LS_FL,			/* file, default */
+	LS_DI,			/* directory */
+	LS_LN,			/* symlink */
+
+	LS_PI,			/* pipe */
+	LS_SO,			/* socket */
+	LS_BD,			/* block device */
+	LS_CD,			/* char device */
+	LS_MI,			/* missing file */
+	LS_OR,			/* orphaned symlink */
+	LS_EX,			/* executable */
+	LS_DO,			/* Solaris door */
+
+	LS_SU,			/* setuid */
+	LS_SG,			/* setgid */
+	LS_ST,			/* sticky */
+	LS_OW,			/* other-writable */
+	LS_TW,			/* ow with sticky */
+	LS_CA,			/* cap */
+	LS_MH,			/* multi hardlink */
+	LS_CL,			/* clear end of line */
+
+	MAX_LS
+};
+
+static char ls_colors[MAX_LS][COLOR_MAXLEN] = {
+	"",
+	"",
+	"",
+	GIT_COLOR_RESET,
+	GIT_COLOR_NORMAL,
+	GIT_COLOR_NORMAL,
+	GIT_COLOR_BOLD_BLUE,
+	GIT_COLOR_BOLD_CYAN,
+
+	GIT_COLOR_YELLOW,
+	GIT_COLOR_BOLD_MAGENTA,
+	GIT_COLOR_BOLD_YELLOW,
+	GIT_COLOR_BOLD_YELLOW,
+	GIT_COLOR_NORMAL,
+	GIT_COLOR_NORMAL,
+	GIT_COLOR_BOLD_GREEN,
+	GIT_COLOR_BOLD_MAGENTA,
+
+	GIT_COLOR_WHITE_ON_RED,
+	GIT_COLOR_BLACK_ON_YELLOW,
+	GIT_COLOR_WHITE_ON_BLUE,
+	GIT_COLOR_BLUE_ON_GREEN,
+	GIT_COLOR_BLACK_ON_GREEN,
+	"",
+	"",
+	""
+};
+
+static const char *const indicator_name[] = {
+	"lc", "rc", "ec", "rs", "no", "fi", "di", "ln",
+	"pi", "so", "bd", "cd", "mi", "or", "ex", "do",
+	"su", "sg", "st", "ow", "tw", "ca", "mh", "cl",
+	NULL
+};
+
+struct bin_str {
+	size_t len;			/* Number of bytes */
+	const char *string;		/* Pointer to the same */
+};
+
+struct color_ext_type {
+	struct bin_str ext;		/* The extension we're looking for */
+	struct bin_str seq;		/* The sequence to output when we do */
+	struct color_ext_type *next;	/* Next in list */
+};
+
+static struct color_ext_type *color_ext_list = NULL;
+
+/*
+ * When true, in a color listing, color each symlink name according to the
+ * type of file it points to.  Otherwise, color them according to the `ln'
+ * directive in LS_COLORS.  Dangling (orphan) symlinks are treated specially,
+ * regardless.  This is set when `ln=target' appears in LS_COLORS.
+ */
+static int color_symlink_as_referent;
+
+/*
+ * Parse a string as part of the LS_COLORS variable; this may involve
+ * decoding all kinds of escape characters.  If equals_end is set an
+ * unescaped equal sign ends the string, otherwise only a : or \0
+ * does.  Set *OUTPUT_COUNT to the number of bytes output.  Return
+ * true if successful.
+ *
+ * The resulting string is *not* null-terminated, but may contain
+ * embedded nulls.
+ *
+ * Note that both dest and src are char **; on return they point to
+ * the first free byte after the array and the character that ended
+ * the input string, respectively.
+ */
+static int get_funky_string(char **dest, const char **src, int equals_end,
+			    size_t *output_count)
+{
+	char num;			/* For numerical codes */
+	size_t count;			/* Something to count with */
+	enum {
+		ST_GND, ST_BACKSLASH, ST_OCTAL, ST_HEX,
+		ST_CARET, ST_END, ST_ERROR
+	} state;
+	const char *p;
+	char *q;
+
+	p = *src;			/* We don't want to double-indirect */
+	q = *dest;			/* the whole darn time.  */
+
+	count = 0;			/* No characters counted in yet.  */
+	num = 0;
+
+	state = ST_GND;		/* Start in ground state.  */
+	while (state < ST_END) {
+		switch (state) {
+		case ST_GND:		/* Ground state (no escapes) */
+			switch (*p) {
+			case ':':
+			case '\0':
+				state = ST_END;	/* End of string */
+				break;
+			case '\\':
+				state = ST_BACKSLASH; /* Backslash scape sequence */
+				++p;
+				break;
+			case '^':
+				state = ST_CARET; /* Caret escape */
+				++p;
+				break;
+			case '=':
+				if (equals_end) {
+					state = ST_END; /* End */
+					break;
+				}
+				/* else fall through */
+			default:
+				*(q++) = *(p++);
+				++count;
+				break;
+			}
+			break;
+
+		case ST_BACKSLASH:	/* Backslash escaped character */
+			switch (*p) {
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+				state = ST_OCTAL;	/* Octal sequence */
+				num = *p - '0';
+				break;
+			case 'x':
+			case 'X':
+				state = ST_HEX;	/* Hex sequence */
+				num = 0;
+				break;
+			case 'a':		/* Bell */
+				num = '\a';
+				break;
+			case 'b':		/* Backspace */
+				num = '\b';
+				break;
+			case 'e':		/* Escape */
+				num = 27;
+				break;
+			case 'f':		/* Form feed */
+				num = '\f';
+				break;
+			case 'n':		/* Newline */
+				num = '\n';
+				break;
+			case 'r':		/* Carriage return */
+				num = '\r';
+				break;
+			case 't':		/* Tab */
+				num = '\t';
+				break;
+			case 'v':		/* Vtab */
+				num = '\v';
+				break;
+			case '?':		/* Delete */
+				num = 127;
+				break;
+			case '_':		/* Space */
+				num = ' ';
+				break;
+			case '\0':		/* End of string */
+				state = ST_ERROR;	/* Error! */
+				break;
+			default:		/* Escaped character like \ ^ : = */
+				num = *p;
+				break;
+			}
+			if (state == ST_BACKSLASH) {
+				*(q++) = num;
+				++count;
+				state = ST_GND;
+			}
+			++p;
+			break;
+
+		case ST_OCTAL:		/* Octal sequence */
+			if (*p < '0' || *p > '7') {
+				*(q++) = num;
+				++count;
+				state = ST_GND;
+			} else
+				num = (num << 3) + (*(p++) - '0');
+			break;
+
+		case ST_HEX:		/* Hex sequence */
+			switch (*p) {
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+			case '8':
+			case '9':
+				num = (num << 4) + (*(p++) - '0');
+				break;
+			case 'a':
+			case 'b':
+			case 'c':
+			case 'd':
+			case 'e':
+			case 'f':
+				num = (num << 4) + (*(p++) - 'a') + 10;
+				break;
+			case 'A':
+			case 'B':
+			case 'C':
+			case 'D':
+			case 'E':
+			case 'F':
+				num = (num << 4) + (*(p++) - 'A') + 10;
+				break;
+			default:
+				*(q++) = num;
+				++count;
+				state = ST_GND;
+				break;
+			}
+			break;
+
+		case ST_CARET:		/* Caret escape */
+			state = ST_GND;	/* Should be the next state... */
+			if (*p >= '@' && *p <= '~') {
+				*(q++) = *(p++) & 037;
+				++count;
+			} else if (*p == '?') {
+				*(q++) = 127;
+				++count;
+			} else
+				state = ST_ERROR;
+			break;
+
+		default:
+			abort();
+		}
+	}
+
+	*dest = q;
+	*src = p;
+	*output_count = count;
+
+	return state != ST_ERROR;
+}
+
+void parse_ls_color(void)
+{
+	const char *p;			/* Pointer to character being parsed */
+	char *buf;			/* color_buf buffer pointer */
+	int state;			/* State of parser */
+	int ind_no;			/* Indicator number */
+	char label[3];			/* Indicator label */
+	struct color_ext_type *ext;	/* Extension we are working on */
+	static char *color_buf;
+	char *start;
+	size_t len;
+
+	if ((p = getenv("LS_COLORS")) == NULL || *p == '\0')
+		return;
+
+	ext = NULL;
+	strcpy (label, "??");
+
+	/*
+	 * This is an overly conservative estimate, but any possible
+	 * LS_COLORS string will *not* generate a color_buf longer
+	 * than itself, so it is a safe way of allocating a buffer in
+	 * advance.
+	 */
+	buf = color_buf = xstrdup(p);
+
+	state = 1;
+	while (state > 0) {
+		switch (state) {
+		case 1:		/* First label character */
+			switch (*p) {
+			case ':':
+				++p;
+				break;
+
+			case '*':
+				/*
+				 * Allocate new extension block and add to head of
+				 * linked list (this way a later definition will
+				 * override an earlier one, which can be useful for
+				 * having terminal-specific defs override global).
+				 */
+
+				ext = xmalloc(sizeof *ext);
+				ext->next = color_ext_list;
+				color_ext_list = ext;
+
+				++p;
+				ext->ext.string = buf;
+
+				state = (get_funky_string(&buf, &p, 1, &ext->ext.len)
+					 ? 4 : -1);
+				break;
+
+			case '\0':
+				state = 0;	/* Done! */
+				break;
+
+			default:	/* Assume it is file type label */
+				label[0] = *(p++);
+				state = 2;
+				break;
+			}
+			break;
+
+		case 2:		/* Second label character */
+			if (*p) {
+				label[1] = *(p++);
+				state = 3;
+			} else
+				state = -1;	/* Error */
+			break;
+
+		case 3:		/* Equal sign after indicator label */
+			state = -1;	/* Assume failure...  */
+			if (*(p++) != '=')
+				break;
+			for (ind_no = 0; indicator_name[ind_no] != NULL; ++ind_no) {
+				if (!strcmp(label, indicator_name[ind_no])) {
+					start = buf;
+					if (get_funky_string(&buf, &p, 0, &len))
+						state = 1;
+					else
+						state = -1;
+					break;
+				}
+			}
+			if (state == -1)
+				error(_("unrecognized prefix: %s"), label);
+			else if (ind_no == LS_LN && len == 6 &&
+				 starts_with(start, "target"))
+				color_symlink_as_referent = 1;
+			else
+				sprintf(ls_colors[ind_no], "\033[%.*sm",
+				       (int)len, start);
+			break;
+
+		case 4:		/* Equal sign after *.ext */
+			if (*(p++) == '=') {
+				ext->seq.string = buf;
+				state = (get_funky_string(&buf, &p, 0, &ext->seq.len)
+					 ? 1 : -1);
+			} else
+				state = -1;
+			break;
+		}
+	}
+
+	if (!strcmp(ls_colors[LS_LN], "target"))
+		color_symlink_as_referent = 1;
+}
-- 
1.9.1.345.ga1a145c

[PATCH v2 02/17] ls_colors.c: parse color.ls.* from config file

[Nguyễn Thái Ngọc Duy]

This is the second (and preferred) source for color information. This
will override $LS_COLORS.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/config.txt | 11 +++++++++++
 ls_colors.c              | 26 ++++++++++++++++++++++++++
 2 files changed, 37 insertions(+)

diff --git a/Documentation/config.txt b/Documentation/config.txt
index 73c8973..3fb754e 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -909,6 +909,17 @@ color.status.<slot>::
 	to red). The values of these variables may be specified as in
 	color.branch.<slot>.
 
+color.ls.<slot>::
+	Use customized color for file name colorization. If not set
+	and the environment variable LS_COLORS is set, color settings
+	from $LS_COLORS are used. `<slot>` can be `normal`, `file`,
+	`directory`, `symlink`, `fifo`, `socket`, `block`, `char`,
+	`missing`, `orphan`, `executable`, `door`, `setuid`, `setgid`,
+	`sticky`, `otherwritable`, `stickyotherwritable`, `cap`,
+	`multihardlink`. The values of these variables may be
+	specified as in color.branch.<slot>.
+
+
 color.ui::
 	This variable determines the default value for variables such
 	as `color.diff` and `color.grep` that control the use of color
diff --git a/ls_colors.c b/ls_colors.c
index eb944f4..cef5a92 100644
--- a/ls_colors.c
+++ b/ls_colors.c
@@ -68,6 +68,14 @@ static const char *const indicator_name[] = {
 	NULL
 };
 
+static const char* const config_name[] = {
+	"", "", "", "", "normal", "file", "directory", "symlink",
+	"fifo", "socket", "block", "char", "missing", "orphan", "executable",
+	"door", "setuid", "setgid", "sticky", "otherwritable",
+	"stickyotherwritable", "cap", "multihardlink", "",
+	NULL
+};
+
 struct bin_str {
 	size_t len;			/* Number of bytes */
 	const char *string;		/* Pointer to the same */
@@ -285,6 +293,23 @@ static int get_funky_string(char **dest, const char **src, int equals_end,
 	return state != ST_ERROR;
 }
 
+static int ls_colors_config(const char *var, const char *value, void *cb)
+{
+	int slot;
+	if (!starts_with(var, "color.ls."))
+		return 0;
+	var += 9;
+	for (slot = 0; config_name[slot]; slot++)
+		if (!strcasecmp(var, config_name[slot]))
+			break;
+	if (!config_name[slot])
+		return 0;
+	if (!value)
+		return config_error_nonbool(var);
+	color_parse(value, var, ls_colors[slot]);
+	return 0;
+}
+
 void parse_ls_color(void)
 {
 	const char *p;			/* Pointer to character being parsed */
@@ -395,4 +420,5 @@ void parse_ls_color(void)
 
 	if (!strcmp(ls_colors[LS_LN], "target"))
 		color_symlink_as_referent = 1;
+	git_config(ls_colors_config, NULL);
 }
-- 
1.9.1.345.ga1a145c

[PATCH v2 03/17] ls_colors.c: add function to color a file name

[Nguyễn Thái Ngọc Duy]

Tthe new function is based on print_color_indicator() from commit
7326d1f1a67edf21947ae98194f98c38b6e9e527 in coreutils.git.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 color.h     |  2 ++
 ls_colors.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+)

diff --git a/color.h b/color.h
index 640fc48..398369a 100644
--- a/color.h
+++ b/color.h
@@ -94,5 +94,7 @@ void color_print_strbuf(FILE *fp, const char *color, const struct strbuf *sb);
 int color_is_nil(const char *color);
 
 void parse_ls_color(void);
+void color_filename(struct strbuf *sb, const char *name,
+		    const char *display_name, mode_t mode, int linkok);
 
 #endif /* COLOR_H */
diff --git a/ls_colors.c b/ls_colors.c
index cef5a92..1125329 100644
--- a/ls_colors.c
+++ b/ls_colors.c
@@ -422,3 +422,69 @@ void parse_ls_color(void)
 		color_symlink_as_referent = 1;
 	git_config(ls_colors_config, NULL);
 }
+
+void color_filename(struct strbuf *sb, const char *name,
+		    const char *display_name, mode_t mode, int linkok)
+{
+	int type;
+	struct color_ext_type *ext;	/* Color extension */
+
+	if (S_ISREG (mode)) {
+		type = LS_FL;
+		if ((mode & S_ISUID) != 0)
+			type = LS_SU;
+		else if ((mode & S_ISGID) != 0)
+			type = LS_SG;
+		else if ((mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0)
+			type = LS_EX;
+	} else if (S_ISDIR (mode)) {
+		if ((mode & S_ISVTX) && (mode & S_IWOTH))
+			type = LS_TW;
+		else if ((mode & S_IWOTH) != 0)
+			type = LS_OW;
+		else if ((mode & S_ISVTX) != 0)
+			type = LS_ST;
+		else
+			type = LS_DI;
+	} else if (S_ISLNK (mode))
+		type = (!linkok && *ls_colors[LS_OR]) ? LS_OR : LS_LN;
+	else if (S_ISFIFO (mode))
+		type = LS_PI;
+	else if (S_ISSOCK (mode))
+		type = LS_SO;
+	else if (S_ISBLK (mode))
+		type = LS_BD;
+	else if (S_ISCHR (mode))
+		type = LS_CD;
+#ifdef S_ISDOOR
+	else if (S_ISDOOR (mode))
+		type = LS_DO;
+#endif
+	else
+		/* Classify a file of some other type as C_ORPHAN.  */
+		type = LS_OR;
+
+	/* Check the file's suffix only if still classified as C_FILE.  */
+	ext = NULL;
+	if (type == LS_FL) {
+		/* Test if NAME has a recognized suffix.  */
+		size_t len = strlen(name);
+		const char *p = name + len;		/* Pointer to final \0.  */
+		for (ext = color_ext_list; ext != NULL; ext = ext->next) {
+			if (ext->ext.len <= len &&
+			    !strncmp(p - ext->ext.len, ext->ext.string, ext->ext.len))
+				break;
+		}
+	}
+
+	if (display_name)
+		name = display_name;
+	if (ext)
+		strbuf_addf(sb, "\033[%.*sm%s%s",
+			    (int)ext->seq.len, ext->seq.string,
+			    name, GIT_COLOR_RESET);
+	else if (*ls_colors[type])
+		strbuf_addf(sb, "%s%s%s", ls_colors[type], name, GIT_COLOR_RESET);
+	else
+		strbuf_addstr(sb, name);
+}
-- 
1.9.1.345.ga1a145c

[PATCH v2 04/17] ls_colors.c: highlight submodules like directories

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/config.txt | 3 ++-
 ls_colors.c              | 8 +++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/Documentation/config.txt b/Documentation/config.txt
index 3fb754e..6bca55e 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -913,7 +913,8 @@ color.ls.<slot>::
 	Use customized color for file name colorization. If not set
 	and the environment variable LS_COLORS is set, color settings
 	from $LS_COLORS are used. `<slot>` can be `normal`, `file`,
-	`directory`, `symlink`, `fifo`, `socket`, `block`, `char`,
+	`directory`, `submodule`,
+	`symlink`, `fifo`, `socket`, `block`, `char`,
 	`missing`, `orphan`, `executable`, `door`, `setuid`, `setgid`,
 	`sticky`, `otherwritable`, `stickyotherwritable`, `cap`,
 	`multihardlink`. The values of these variables may be
diff --git a/ls_colors.c b/ls_colors.c
index 1125329..0cc4e9b 100644
--- a/ls_colors.c
+++ b/ls_colors.c
@@ -29,6 +29,8 @@ enum color_ls {
 	LS_MH,			/* multi hardlink */
 	LS_CL,			/* clear end of line */
 
+	LS_SUBMODULE,
+
 	MAX_LS
 };
 
@@ -58,7 +60,8 @@ static char ls_colors[MAX_LS][COLOR_MAXLEN] = {
 	GIT_COLOR_BLACK_ON_GREEN,
 	"",
 	"",
-	""
+	"",
+	GIT_COLOR_BOLD_BLUE
 };
 
 static const char *const indicator_name[] = {
@@ -73,6 +76,7 @@ static const char* const config_name[] = {
 	"fifo", "socket", "block", "char", "missing", "orphan", "executable",
 	"door", "setuid", "setgid", "sticky", "otherwritable",
 	"stickyotherwritable", "cap", "multihardlink", "",
+	"submodule",
 	NULL
 };
 
@@ -448,6 +452,8 @@ void color_filename(struct strbuf *sb, const char *name,
 			type = LS_DI;
 	} else if (S_ISLNK (mode))
 		type = (!linkok && *ls_colors[LS_OR]) ? LS_OR : LS_LN;
+	else if (S_ISGITLINK(mode))
+		type = LS_SUBMODULE;
 	else if (S_ISFIFO (mode))
 		type = LS_PI;
 	else if (S_ISSOCK (mode))
-- 
1.9.1.345.ga1a145c

[PATCH v2 05/17] ls-files: buffer full item in strbuf before printing

[Nguyễn Thái Ngọc Duy]

Buffering so that we can manipulate the strings (e.g. coloring)
further before finally printing them.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 48 +++++++++++++++++++++++++++++++++++-------------
 1 file changed, 35 insertions(+), 13 deletions(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 47c3880..6e30592 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -47,18 +47,30 @@ static const char *tag_modified = "";
 static const char *tag_skip_worktree = "";
 static const char *tag_resolve_undo = "";
 
-static void write_name(const char *name)
+static void write_name(struct strbuf *sb, const char *name)
 {
 	/*
 	 * With "--full-name", prefix_len=0; this caller needs to pass
 	 * an empty string in that case (a NULL is good for "").
 	 */
-	write_name_quoted_relative(name, prefix_len ? prefix : NULL,
-				   stdout, line_terminator);
+	const char *real_prefix = prefix_len ? prefix : NULL;
+	if (!line_terminator) {
+		struct strbuf sb2 = STRBUF_INIT;
+		strbuf_addstr(sb, relative_path(name, real_prefix, &sb2));
+		strbuf_release(&sb2);
+	} else
+		quote_path_relative(name, real_prefix, sb);
+	strbuf_addch(sb, line_terminator);
+}
+
+static void strbuf_fputs(struct strbuf *sb, FILE *fp)
+{
+	fwrite(sb->buf, sb->len, 1, fp);
 }
 
 static void show_dir_entry(const char *tag, struct dir_entry *ent)
 {
+	static struct strbuf sb = STRBUF_INIT;
 	int len = max_prefix_len;
 
 	if (len >= ent->len)
@@ -67,8 +79,10 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
 	if (!dir_path_match(ent, &pathspec, len, ps_matched))
 		return;
 
-	fputs(tag, stdout);
-	write_name(ent->name);
+	strbuf_reset(&sb);
+	strbuf_addstr(&sb, tag);
+	write_name(&sb, ent->name);
+	strbuf_fputs(&sb, stdout);
 }
 
 static void show_other_files(struct dir_struct *dir)
@@ -134,6 +148,7 @@ static void show_killed_files(struct dir_struct *dir)
 
 static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 {
+	static struct strbuf sb = STRBUF_INIT;
 	int len = max_prefix_len;
 
 	if (len >= ce_namelen(ce))
@@ -161,16 +176,18 @@ static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 		tag = alttag;
 	}
 
+	strbuf_reset(&sb);
 	if (!show_stage) {
-		fputs(tag, stdout);
+		strbuf_addstr(&sb, tag);
 	} else {
-		printf("%s%06o %s %d\t",
-		       tag,
-		       ce->ce_mode,
-		       find_unique_abbrev(ce->sha1,abbrev),
-		       ce_stage(ce));
+		strbuf_addf(&sb, "%s%06o %s %d\t",
+			    tag,
+			    ce->ce_mode,
+			    find_unique_abbrev(ce->sha1,abbrev),
+			    ce_stage(ce));
 	}
-	write_name(ce->name);
+	write_name(&sb, ce->name);
+	strbuf_fputs(&sb, stdout);
 	if (debug_mode) {
 		const struct stat_data *sd = &ce->ce_stat_data;
 
@@ -206,7 +223,12 @@ static void show_ru_info(void)
 			printf("%s%06o %s %d\t", tag_resolve_undo, ui->mode[i],
 			       find_unique_abbrev(ui->sha1[i], abbrev),
 			       i + 1);
-			write_name(path);
+			/*
+			 * With "--full-name", prefix_len=0; this caller needs to pass
+			 * an empty string in that case (a NULL is good for "").
+			 */
+			write_name_quoted_relative(path, prefix_len ? prefix : NULL,
+						   stdout, line_terminator);
 		}
 	}
 }
-- 
1.9.1.345.ga1a145c

[PATCH v2 06/17] ls-files: add --color to highlight file names

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-ls-files.txt |  9 +++++++++
 builtin/ls-files.c             | 38 +++++++++++++++++++++++++++++++++++---
 2 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
index c0856a6..5c1b7f3 100644
--- a/Documentation/git-ls-files.txt
+++ b/Documentation/git-ls-files.txt
@@ -147,6 +147,15 @@ a space) at the start of each line:
 	possible for manual inspection; the exact format may change at
 	any time.
 
+--color[=<when>]::
+	Color file names. The value must be always (default), never,
+	or auto.
+
+--no-color::
+	Turn off coloring, even when the configuration file gives the
+	default to color output, same as `--color=never`. This is the
+	default.
+
 \--::
 	Do not interpret any more arguments as options.
 
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 6e30592..2857b38 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -14,6 +14,7 @@
 #include "resolve-undo.h"
 #include "string-list.h"
 #include "pathspec.h"
+#include "color.h"
 
 static int abbrev;
 static int show_deleted;
@@ -27,6 +28,7 @@ static int show_killed;
 static int show_valid_bit;
 static int line_terminator = '\n';
 static int debug_mode;
+static int use_color;
 
 static const char *prefix;
 static int max_prefix_len;
@@ -60,7 +62,6 @@ static void write_name(struct strbuf *sb, const char *name)
 		strbuf_release(&sb2);
 	} else
 		quote_path_relative(name, real_prefix, sb);
-	strbuf_addch(sb, line_terminator);
 }
 
 static void strbuf_fputs(struct strbuf *sb, FILE *fp)
@@ -68,6 +69,21 @@ static void strbuf_fputs(struct strbuf *sb, FILE *fp)
 	fwrite(sb->buf, sb->len, 1, fp);
 }
 
+static void write_dir_entry(struct strbuf *sb, const struct dir_entry *ent)
+{
+	struct strbuf quoted = STRBUF_INIT;
+	struct stat st;
+	if (stat(ent->name, &st))
+		st.st_mode = 0;
+	write_name(&quoted, ent->name);
+	if (want_color(use_color))
+		color_filename(sb, ent->name, quoted.buf, st.st_mode, 1);
+	else
+		strbuf_addbuf(sb, &quoted);
+	strbuf_addch(sb, line_terminator);
+	strbuf_release(&quoted);
+}
+
 static void show_dir_entry(const char *tag, struct dir_entry *ent)
 {
 	static struct strbuf sb = STRBUF_INIT;
@@ -81,7 +97,7 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
 
 	strbuf_reset(&sb);
 	strbuf_addstr(&sb, tag);
-	write_name(&sb, ent->name);
+	write_dir_entry(&sb, ent);
 	strbuf_fputs(&sb, stdout);
 }
 
@@ -146,6 +162,18 @@ static void show_killed_files(struct dir_struct *dir)
 	}
 }
 
+static void write_ce_name(struct strbuf *sb, const struct cache_entry *ce)
+{
+	struct strbuf quoted = STRBUF_INIT;
+	write_name(&quoted, ce->name);
+	if (want_color(use_color))
+		color_filename(sb, ce->name, quoted.buf, ce->ce_mode, 1);
+	else
+		strbuf_addbuf(sb, &quoted);
+	strbuf_addch(sb, line_terminator);
+	strbuf_release(&quoted);
+}
+
 static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 {
 	static struct strbuf sb = STRBUF_INIT;
@@ -186,7 +214,7 @@ static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 			    find_unique_abbrev(ce->sha1,abbrev),
 			    ce_stage(ce));
 	}
-	write_name(&sb, ce->name);
+	write_ce_name(&sb, ce);
 	strbuf_fputs(&sb, stdout);
 	if (debug_mode) {
 		const struct stat_data *sd = &ce->ce_stat_data;
@@ -523,6 +551,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			N_("if any <file> is not in the index, treat this as an error")),
 		OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
 			N_("pretend that paths removed since <tree-ish> are still present")),
+		OPT__COLOR(&use_color, N_("show color")),
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -570,6 +599,9 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	if (require_work_tree && !is_inside_work_tree())
 		setup_work_tree();
 
+	if (want_color(use_color))
+		parse_ls_color();
+
 	parse_pathspec(&pathspec, 0,
 		       PATHSPEC_PREFER_CWD |
 		       PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
-- 
1.9.1.345.ga1a145c

[PATCH v2 07/17] ls-files: add --column

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-ls-files.txt |  6 ++++++
 builtin/ls-files.c             | 25 +++++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
index 5c1b7f3..cd52461 100644
--- a/Documentation/git-ls-files.txt
+++ b/Documentation/git-ls-files.txt
@@ -156,6 +156,12 @@ a space) at the start of each line:
 	default to color output, same as `--color=never`. This is the
 	default.
 
+--column[=<options>]::
+--no-column::
+	Display files in columns. See configuration variable column.ui
+	for option syntax.`--column` and `--no-column` without options
+	are equivalent to 'always' and 'never' respectively.
+
 \--::
 	Do not interpret any more arguments as options.
 
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 2857b38..335d3b0 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -15,6 +15,7 @@
 #include "string-list.h"
 #include "pathspec.h"
 #include "color.h"
+#include "column.h"
 
 static int abbrev;
 static int show_deleted;
@@ -29,6 +30,7 @@ static int show_valid_bit;
 static int line_terminator = '\n';
 static int debug_mode;
 static int use_color;
+static unsigned int colopts;
 
 static const char *prefix;
 static int max_prefix_len;
@@ -39,6 +41,7 @@ static char *ps_matched;
 static const char *with_tree;
 static int exc_given;
 static int exclude_args;
+static struct string_list output = STRING_LIST_INIT_NODUP;
 
 static const char *tag_cached = "";
 static const char *tag_unmerged = "";
@@ -66,6 +69,10 @@ static void write_name(struct strbuf *sb, const char *name)
 
 static void strbuf_fputs(struct strbuf *sb, FILE *fp)
 {
+	if (column_active(colopts)) {
+		string_list_append(&output, strbuf_detach(sb, NULL));
+		return;
+	}
 	fwrite(sb->buf, sb->len, 1, fp);
 }
 
@@ -552,6 +559,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
 			N_("pretend that paths removed since <tree-ish> are still present")),
 		OPT__COLOR(&use_color, N_("show color")),
+		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -596,6 +604,18 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	if (dir.exclude_per_dir)
 		exc_given = 1;
 
+	finalize_colopts(&colopts, -1);
+	if (explicitly_enable_column(colopts)) {
+		if (!line_terminator)
+			die(_("--column and -z are incompatible"));
+		if (show_resolve_undo)
+			die(_("--column and --resolve-undo are incompatible"));
+		if (debug_mode)
+			die(_("--column and --debug are incompatible"));
+	}
+	if (column_active(colopts))
+		line_terminator = 0;
+
 	if (require_work_tree && !is_inside_work_tree())
 		setup_work_tree();
 
@@ -638,6 +658,11 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	if (show_resolve_undo)
 		show_ru_info();
 
+	if (column_active(colopts)) {
+		print_columns(&output, colopts, NULL);
+		string_list_clear(&output, 0);
+	}
+
 	if (ps_matched) {
 		int bad;
 		bad = report_path_error(ps_matched, &pathspec, prefix);
-- 
1.9.1.345.ga1a145c

[PATCH v2 08/17] ls-files: support --max-depth

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-ls-files.txt | 7 +++++++
 builtin/ls-files.c             | 7 +++++++
 2 files changed, 14 insertions(+)

diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
index cd52461..3c022eb 100644
--- a/Documentation/git-ls-files.txt
+++ b/Documentation/git-ls-files.txt
@@ -162,6 +162,13 @@ a space) at the start of each line:
 	for option syntax.`--column` and `--no-column` without options
 	are equivalent to 'always' and 'never' respectively.
 
+--max-depth <depth>::
+	For each <pathspec> given on command line, descend at most <depth>
+	levels of directories. A negative value means no limit.
+	This option is ignored if <pathspec> contains active wildcards.
+	In other words if "a*" matches a directory named "a*",
+	"*" is matched literally so --max-depth is still effective.
+
 \--::
 	Do not interpret any more arguments as options.
 
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 335d3b0..8eef423 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -503,6 +503,7 @@ static int option_parse_exclude_standard(const struct option *opt,
 int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 {
 	int require_work_tree = 0, show_tag = 0, i;
+	int max_depth = -1;
 	const char *max_prefix;
 	struct dir_struct dir;
 	struct exclude_list *el;
@@ -560,6 +561,9 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			N_("pretend that paths removed since <tree-ish> are still present")),
 		OPT__COLOR(&use_color, N_("show color")),
 		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
+		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
+			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
+			NULL, 1 },
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -624,8 +628,11 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 
 	parse_pathspec(&pathspec, 0,
 		       PATHSPEC_PREFER_CWD |
+		       (max_depth != -1 ? PATHSPEC_MAXDEPTH_VALID : 0) |
 		       PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
 		       prefix, argv);
+	pathspec.max_depth = max_depth;
+	pathspec.recursive = 1;
 
 	/* Find common prefix for all pathspec's */
 	max_prefix = common_prefix(&pathspec);
-- 
1.9.1.345.ga1a145c

[PATCH v2 09/17] ls-files: split main ls-files logic into ls_files() function

[Nguyễn Thái Ngọc Duy]

This is a preparation step for the introduction of git-ls. "git ls"
has a different set of command line options, but it will eventually
call ls_files().

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 164 +++++++++++++++++++++++++++--------------------------
 1 file changed, 85 insertions(+), 79 deletions(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 8eef423..20ca3f2 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -31,6 +31,8 @@ static int line_terminator = '\n';
 static int debug_mode;
 static int use_color;
 static unsigned int colopts;
+static int max_depth = -1;
+static int show_tag;
 
 static const char *prefix;
 static int max_prefix_len;
@@ -42,6 +44,8 @@ static const char *with_tree;
 static int exc_given;
 static int exclude_args;
 static struct string_list output = STRING_LIST_INIT_NODUP;
+static struct dir_struct dir;
+static struct string_list exclude_list = STRING_LIST_INIT_NODUP;
 
 static const char *tag_cached = "";
 static const char *tag_unmerged = "";
@@ -500,89 +504,12 @@ static int option_parse_exclude_standard(const struct option *opt,
 	return 0;
 }
 
-int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
+static int ls_files(const char **argv, const char *prefix)
 {
-	int require_work_tree = 0, show_tag = 0, i;
-	int max_depth = -1;
+	int require_work_tree = 0, i;
 	const char *max_prefix;
-	struct dir_struct dir;
 	struct exclude_list *el;
-	struct string_list exclude_list = STRING_LIST_INIT_NODUP;
-	struct option builtin_ls_files_options[] = {
-		{ OPTION_CALLBACK, 'z', NULL, NULL, NULL,
-			N_("paths are separated with NUL character"),
-			PARSE_OPT_NOARG, option_parse_z },
-		OPT_BOOL('t', NULL, &show_tag,
-			N_("identify the file status with tags")),
-		OPT_BOOL('v', NULL, &show_valid_bit,
-			N_("use lowercase letters for 'assume unchanged' files")),
-		OPT_BOOL('c', "cached", &show_cached,
-			N_("show cached files in the output (default)")),
-		OPT_BOOL('d', "deleted", &show_deleted,
-			N_("show deleted files in the output")),
-		OPT_BOOL('m', "modified", &show_modified,
-			N_("show modified files in the output")),
-		OPT_BOOL('o', "others", &show_others,
-			N_("show other files in the output")),
-		OPT_BIT('i', "ignored", &dir.flags,
-			N_("show ignored files in the output"),
-			DIR_SHOW_IGNORED),
-		OPT_BOOL('s', "stage", &show_stage,
-			N_("show staged contents' object name in the output")),
-		OPT_BOOL('k', "killed", &show_killed,
-			N_("show files on the filesystem that need to be removed")),
-		OPT_BIT(0, "directory", &dir.flags,
-			N_("show 'other' directories' name only"),
-			DIR_SHOW_OTHER_DIRECTORIES),
-		OPT_NEGBIT(0, "empty-directory", &dir.flags,
-			N_("don't show empty directories"),
-			DIR_HIDE_EMPTY_DIRECTORIES),
-		OPT_BOOL('u', "unmerged", &show_unmerged,
-			N_("show unmerged files in the output")),
-		OPT_BOOL(0, "resolve-undo", &show_resolve_undo,
-			    N_("show resolve-undo information")),
-		{ OPTION_CALLBACK, 'x', "exclude", &exclude_list, N_("pattern"),
-			N_("skip files matching pattern"),
-			0, option_parse_exclude },
-		{ OPTION_CALLBACK, 'X', "exclude-from", &dir, N_("file"),
-			N_("exclude patterns are read from <file>"),
-			0, option_parse_exclude_from },
-		OPT_STRING(0, "exclude-per-directory", &dir.exclude_per_dir, N_("file"),
-			N_("read additional per-directory exclude patterns in <file>")),
-		{ OPTION_CALLBACK, 0, "exclude-standard", &dir, NULL,
-			N_("add the standard git exclusions"),
-			PARSE_OPT_NOARG, option_parse_exclude_standard },
-		{ OPTION_SET_INT, 0, "full-name", &prefix_len, NULL,
-			N_("make the output relative to the project top directory"),
-			PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL },
-		OPT_BOOL(0, "error-unmatch", &error_unmatch,
-			N_("if any <file> is not in the index, treat this as an error")),
-		OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
-			N_("pretend that paths removed since <tree-ish> are still present")),
-		OPT__COLOR(&use_color, N_("show color")),
-		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
-		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
-			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
-			NULL, 1 },
-		OPT__ABBREV(&abbrev),
-		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
-		OPT_END()
-	};
-
-	if (argc == 2 && !strcmp(argv[1], "-h"))
-		usage_with_options(ls_files_usage, builtin_ls_files_options);
 
-	memset(&dir, 0, sizeof(dir));
-	prefix = cmd_prefix;
-	if (prefix)
-		prefix_len = strlen(prefix);
-	git_config(git_default_config, NULL);
-
-	if (read_cache() < 0)
-		die("index file corrupt");
-
-	argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
-			ls_files_usage, 0);
 	el = add_exclude_list(&dir, EXC_CMDL, "--exclude option");
 	for (i = 0; i < exclude_list.nr; i++) {
 		add_exclude(exclude_list.items[i].string, "", 0, el, --exclude_args);
@@ -681,3 +608,82 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 
 	return 0;
 }
+
+int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
+{
+	struct option builtin_ls_files_options[] = {
+		{ OPTION_CALLBACK, 'z', NULL, NULL, NULL,
+			N_("paths are separated with NUL character"),
+			PARSE_OPT_NOARG, option_parse_z },
+		OPT_BOOL('t', NULL, &show_tag,
+			N_("identify the file status with tags")),
+		OPT_BOOL('v', NULL, &show_valid_bit,
+			N_("use lowercase letters for 'assume unchanged' files")),
+		OPT_BOOL('c', "cached", &show_cached,
+			N_("show cached files in the output (default)")),
+		OPT_BOOL('d', "deleted", &show_deleted,
+			N_("show deleted files in the output")),
+		OPT_BOOL('m', "modified", &show_modified,
+			N_("show modified files in the output")),
+		OPT_BOOL('o', "others", &show_others,
+			N_("show other files in the output")),
+		OPT_BIT('i', "ignored", &dir.flags,
+			N_("show ignored files in the output"),
+			DIR_SHOW_IGNORED),
+		OPT_BOOL('s', "stage", &show_stage,
+			N_("show staged contents' object name in the output")),
+		OPT_BOOL('k', "killed", &show_killed,
+			N_("show files on the filesystem that need to be removed")),
+		OPT_BIT(0, "directory", &dir.flags,
+			N_("show 'other' directories' name only"),
+			DIR_SHOW_OTHER_DIRECTORIES),
+		OPT_NEGBIT(0, "empty-directory", &dir.flags,
+			N_("don't show empty directories"),
+			DIR_HIDE_EMPTY_DIRECTORIES),
+		OPT_BOOL('u', "unmerged", &show_unmerged,
+			N_("show unmerged files in the output")),
+		OPT_BOOL(0, "resolve-undo", &show_resolve_undo,
+			    N_("show resolve-undo information")),
+		{ OPTION_CALLBACK, 'x', "exclude", &exclude_list, N_("pattern"),
+			N_("skip files matching pattern"),
+			0, option_parse_exclude },
+		{ OPTION_CALLBACK, 'X', "exclude-from", &dir, N_("file"),
+			N_("exclude patterns are read from <file>"),
+			0, option_parse_exclude_from },
+		OPT_STRING(0, "exclude-per-directory", &dir.exclude_per_dir, N_("file"),
+			N_("read additional per-directory exclude patterns in <file>")),
+		{ OPTION_CALLBACK, 0, "exclude-standard", &dir, NULL,
+			N_("add the standard git exclusions"),
+			PARSE_OPT_NOARG, option_parse_exclude_standard },
+		{ OPTION_SET_INT, 0, "full-name", &prefix_len, NULL,
+			N_("make the output relative to the project top directory"),
+			PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL },
+		OPT_BOOL(0, "error-unmatch", &error_unmatch,
+			N_("if any <file> is not in the index, treat this as an error")),
+		OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
+			N_("pretend that paths removed since <tree-ish> are still present")),
+		OPT__COLOR(&use_color, N_("show color")),
+		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
+		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
+			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
+			NULL, 1 },
+		OPT__ABBREV(&abbrev),
+		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
+		OPT_END()
+	};
+
+	if (argc == 2 && !strcmp(argv[1], "-h"))
+		usage_with_options(ls_files_usage, builtin_ls_files_options);
+
+	prefix = cmd_prefix;
+	if (prefix)
+		prefix_len = strlen(prefix);
+	git_config(git_default_config, NULL);
+
+	if (read_cache() < 0)
+		die("index file corrupt");
+
+	argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
+			ls_files_usage, 0);
+	return ls_files(argv, prefix);
+}
-- 
1.9.1.345.ga1a145c

[PATCH v2 10/17] Add git-ls, a user friendly version of ls-files and more

[Nguyễn Thái Ngọc Duy]

This is more user friendly version of ls-files:

* it's automatically colored and columnized
* it refreshes the index like all porcelain commands
* it defaults to non-recursive behavior like ls
* :(glob) is on by default so '*.c' means a.c but not a/b.c, use
  '**/*.c' for that.
* auto pager

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 .gitignore                     |  1 +
 Documentation/config.txt       | 10 ++++++
 Documentation/git-ls.txt (new) | 82 ++++++++++++++++++++++++++++++++++++++++++
 Makefile                       |  1 +
 builtin.h                      |  1 +
 builtin/ls-files.c             | 70 ++++++++++++++++++++++++++++++++++++
 command-list.txt               |  1 +
 git.c                          |  1 +
 8 files changed, 167 insertions(+)
 create mode 100644 Documentation/git-ls.txt

diff --git a/.gitignore b/.gitignore
index dc600f9..f91af81 100644
--- a/.gitignore
+++ b/.gitignore
@@ -76,6 +76,7 @@
 /git-init-db
 /git-instaweb
 /git-log
+/git-ls
 /git-ls-files
 /git-ls-remote
 /git-ls-tree
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 6bca55e..87a6dcf 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -909,6 +909,12 @@ color.status.<slot>::
 	to red). The values of these variables may be specified as in
 	color.branch.<slot>.
 
+color.ls::
+	A boolean to enable/disable color in the output of
+	linkgit:git-ls[1]. May be set to `always`, `false` (or
+	`never`) or `auto` (or `true`), in which case colors are used
+	only when the output is to a terminal. Defaults to false.
+
 color.ls.<slot>::
 	Use customized color for file name colorization. If not set
 	and the environment variable LS_COLORS is set, color settings
@@ -981,6 +987,10 @@ column.clean::
 	Specify the layout when list items in `git clean -i`, which always
 	shows files and directories in columns. See `column.ui` for details.
 
+column.ls::
+	Specify whether to output tag listing in `git ls` in columns.
+	See `column.ui` for details.
+
 column.status::
 	Specify whether to output untracked files in `git status` in columns.
 	See `column.ui` for details.
diff --git a/Documentation/git-ls.txt b/Documentation/git-ls.txt
new file mode 100644
index 0000000..67ca522
--- /dev/null
+++ b/Documentation/git-ls.txt
@@ -0,0 +1,82 @@
+git-ls(1)
+===============
+
+NAME
+----
+git-ls - List files
+
+SYNOPSIS
+--------
+[verse]
+'git ls' (--[cached|deleted|others|ignored|unmerged|modified])*
+	(-[c|d|o|i|s|u|m])*
+	[options] [<pathspec>...]
+
+DESCRIPTION
+-----------
+List files (by default in current working directory) that are in the
+index. Depending on the chosen options, maybe only modified files in
+working tree are shown, or untracked files...
+
+OPTIONS
+-------
+-c::
+--cached::
+	Show cached files in the output (default)
+
+-d::
+--deleted::
+	Show deleted files in the output
+
+-m::
+--modified::
+	Show modified files in the output
+
+-o::
+--others::
+	Show other (i.e. untracked) files in the output
+
+-i::
+--ignored::
+	Show only ignored files in the output. When showing files in the
+	index, print only those matched by an exclude pattern. When
+	showing "other" files, show only those matched by an exclude
+	pattern.
+
+-u::
+--unmerged::
+	Show unmerged files in the output (forces --stage)
+
+--color[=<when>]::
+	Color file names. The value must be always (default), never,
+	or auto.
+
+--no-color::
+	Turn off coloring, even when the configuration file gives the
+	default to color output, same as `--color=never`. This is the
+	default.
+
+--column[=<options>]::
+--no-column::
+	Display files in columns. See configuration variable column.ui
+	for option syntax.`--column` and `--no-column` without options
+	are equivalent to 'always' and 'never' respectively.
+
+--max-depth <depth>::
+	For each <pathspec> given on command line, descend at most <depth>
+	levels of directories. A negative value means no limit.
+	This option is ignored if <pathspec> contains active wildcards.
+	In other words if "a*" matches a directory named "a*",
+	"*" is matched literally so --max-depth is still effective.
+
+<pathspec>::
+	Files to show. :(glob) magic is enabled and recursion disabled
+	by default.
+
+SEE ALSO
+--------
+linkgit:git-ls-files[1]
+
+GIT
+---
+Part of the linkgit:git[1] suite
diff --git a/Makefile b/Makefile
index f6a6e14..b0bc40a 100644
--- a/Makefile
+++ b/Makefile
@@ -584,6 +584,7 @@ BUILT_INS += git-cherry-pick$X
 BUILT_INS += git-format-patch$X
 BUILT_INS += git-fsck-objects$X
 BUILT_INS += git-init$X
+BUILT_INS += git-ls$X
 BUILT_INS += git-merge-subtree$X
 BUILT_INS += git-show$X
 BUILT_INS += git-stage$X
diff --git a/builtin.h b/builtin.h
index c47c110..177aa7d 100644
--- a/builtin.h
+++ b/builtin.h
@@ -75,6 +75,7 @@ extern int cmd_index_pack(int argc, const char **argv, const char *prefix);
 extern int cmd_init_db(int argc, const char **argv, const char *prefix);
 extern int cmd_log(int argc, const char **argv, const char *prefix);
 extern int cmd_log_reflog(int argc, const char **argv, const char *prefix);
+extern int cmd_ls(int argc, const char **argv, const char *prefix);
 extern int cmd_ls_files(int argc, const char **argv, const char *prefix);
 extern int cmd_ls_tree(int argc, const char **argv, const char *prefix);
 extern int cmd_ls_remote(int argc, const char **argv, const char *prefix);
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 20ca3f2..74eb3c2 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -33,6 +33,7 @@ static int use_color;
 static unsigned int colopts;
 static int max_depth = -1;
 static int show_tag;
+static int porcelain;
 
 static const char *prefix;
 static int max_prefix_len;
@@ -588,6 +589,10 @@ static int ls_files(const char **argv, const char *prefix)
 			die("ls-files --with-tree is incompatible with -s or -u");
 		overlay_tree_on_cache(with_tree, max_prefix);
 	}
+	if (porcelain) {
+		refresh_index(&the_index, REFRESH_QUIET, &pathspec, NULL, NULL);
+		setup_pager();
+	}
 	show_files(&dir);
 	if (show_resolve_undo)
 		show_ru_info();
@@ -687,3 +692,68 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			ls_files_usage, 0);
 	return ls_files(argv, prefix);
 }
+
+static const char * const ls_usage[] = {
+	N_("git ls [options] [<file>...]"),
+	NULL
+};
+
+static int git_ls_config(const char *var, const char *value, void *cb)
+{
+	if (starts_with(var, "column."))
+		return git_column_config(var, value, "ls", &colopts);
+	if (!strcmp(var, "color.ls")) {
+		use_color = git_config_colorbool(var, value);
+		return 0;
+	}
+	return git_color_default_config(var, value, cb);
+}
+
+int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
+{
+	struct option builtin_ls_options[] = {
+		OPT_BOOL('c', "cached", &show_cached,
+			N_("show cached files in the output (default)")),
+		OPT_BOOL('d', "deleted", &show_deleted,
+			N_("show deleted files in the output")),
+		OPT_BOOL('m', "modified", &show_modified,
+			N_("show modified files in the output")),
+		OPT_BOOL('o', "others", &show_others,
+			N_("show other files in the output")),
+		OPT_BIT('i', "ignored", &dir.flags,
+			N_("show ignored files in the output"),
+			DIR_SHOW_IGNORED),
+		OPT_BOOL('u', "unmerged", &show_unmerged,
+			N_("show unmerged files in the output")),
+		OPT__COLOR(&use_color, N_("show color")),
+		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
+		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
+			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
+			NULL, 1 },
+		OPT__ABBREV(&abbrev),
+		OPT_END()
+	};
+
+	if (argc == 2 && !strcmp(argv[1], "-h"))
+		usage_with_options(ls_usage, builtin_ls_options);
+
+	prefix = cmd_prefix;
+	if (prefix)
+		prefix_len = strlen(prefix);
+	git_config(git_ls_config, NULL);
+
+	if (read_cache() < 0)
+		die("index file corrupt");
+
+	/* default setup */
+	porcelain = 1;
+	setenv(GIT_GLOB_PATHSPECS_ENVIRONMENT, "1", 1);
+	exc_given = 1;
+	setup_standard_excludes(&dir);
+	use_color = -1;
+	max_depth = 0;
+
+	argc = parse_options(argc, argv, prefix, builtin_ls_options,
+			     ls_usage, 0);
+	return ls_files(argv, prefix);
+}
diff --git a/command-list.txt b/command-list.txt
index cf36c3d..89e5cef 100644
--- a/command-list.txt
+++ b/command-list.txt
@@ -64,6 +64,7 @@ git-init                                mainporcelain common
 git-instaweb                            ancillaryinterrogators
 gitk                                    mainporcelain
 git-log                                 mainporcelain common
+git-ls                                  mainporcelain
 git-ls-files                            plumbinginterrogators
 git-ls-remote                           plumbinginterrogators
 git-ls-tree                             plumbinginterrogators
diff --git a/git.c b/git.c
index 9efd1a3..682a81e 100644
--- a/git.c
+++ b/git.c
@@ -381,6 +381,7 @@ static struct cmd_struct commands[] = {
 	{ "init", cmd_init_db },
 	{ "init-db", cmd_init_db },
 	{ "log", cmd_log, RUN_SETUP },
+	{ "ls", cmd_ls, RUN_SETUP },
 	{ "ls-files", cmd_ls_files, RUN_SETUP },
 	{ "ls-remote", cmd_ls_remote, RUN_SETUP_GENTLY },
 	{ "ls-tree", cmd_ls_tree, RUN_SETUP },
-- 
1.9.1.345.ga1a145c

[PATCH v2 11/17] ls: -u does not imply showing stages

[Nguyễn Thái Ngọc Duy]

Showing full index entry information is something for ls-files
only. The users of "git ls" may just want to know what entries are not
unmerged.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 74eb3c2..1638983 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -527,7 +527,7 @@ static int ls_files(const char **argv, const char *prefix)
 	}
 	if (show_modified || show_others || show_deleted || (dir.flags & DIR_SHOW_IGNORED) || show_killed)
 		require_work_tree = 1;
-	if (show_unmerged)
+	if (show_unmerged && !porcelain)
 		/*
 		 * There's no point in showing unmerged unless
 		 * you also show the stage information.
-- 
1.9.1.345.ga1a145c

[PATCH v2 12/17] ls: add -R/--recursive short for --max-depth=-1

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-ls.txt | 4 ++++
 builtin/ls-files.c       | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/Documentation/git-ls.txt b/Documentation/git-ls.txt
index 67ca522..10df6b0 100644
--- a/Documentation/git-ls.txt
+++ b/Documentation/git-ls.txt
@@ -47,6 +47,10 @@ OPTIONS
 --unmerged::
 	Show unmerged files in the output (forces --stage)
 
+-R::
+--recursive::
+	Equivalent of --max-depth=-1 (infinite recursion).
+
 --color[=<when>]::
 	Color file names. The value must be always (default), never,
 	or auto.
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 1638983..772a6ce 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -725,6 +725,8 @@ int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
 			DIR_SHOW_IGNORED),
 		OPT_BOOL('u', "unmerged", &show_unmerged,
 			N_("show unmerged files in the output")),
+		OPT_SET_INT('R', "recursive", &max_depth,
+			    N_("shortcut for --max-depth=-1"), -1),
 		OPT__COLOR(&use_color, N_("show color")),
 		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
 		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
-- 
1.9.1.345.ga1a145c

[PATCH v2 13/17] ls: add -1 short for --no-column in the spirit of GNU ls

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-ls.txt | 3 +++
 builtin/ls-files.c       | 2 ++
 2 files changed, 5 insertions(+)

diff --git a/Documentation/git-ls.txt b/Documentation/git-ls.txt
index 10df6b0..0480c42 100644
--- a/Documentation/git-ls.txt
+++ b/Documentation/git-ls.txt
@@ -51,6 +51,9 @@ OPTIONS
 --recursive::
 	Equivalent of --max-depth=-1 (infinite recursion).
 
+-1::
+	Equivalent of --no-column.
+
 --color[=<when>]::
 	Color file names. The value must be always (default), never,
 	or auto.
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 772a6ce..014de05 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -729,6 +729,8 @@ int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
 			    N_("shortcut for --max-depth=-1"), -1),
 		OPT__COLOR(&use_color, N_("show color")),
 		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
+		OPT_SET_INT('1', NULL, &colopts,
+			    N_("shortcut for --no-column"), COL_PARSEOPT),
 		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
 			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
 			NULL, 1 },
-- 
1.9.1.345.ga1a145c

[PATCH v2 14/17] ls: add -t back

[Nguyễn Thái Ngọc Duy]

Tag "H" (cached) is not shown though because it's usually the majority
and becomes noise. Not showing it makes the other tags stand out. -t
is on by default if more than one file category is selected.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-ls.txt |  6 ++++++
 builtin/ls-files.c       | 27 +++++++++++++++++----------
 2 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/Documentation/git-ls.txt b/Documentation/git-ls.txt
index 0480c42..126d9db 100644
--- a/Documentation/git-ls.txt
+++ b/Documentation/git-ls.txt
@@ -47,6 +47,12 @@ OPTIONS
 --unmerged::
 	Show unmerged files in the output (forces --stage)
 
+-t::
+--tag::
+	Show a tag to indicate file type, helpful when multiple file
+	selections are used. See linkgit::git-ls-files[1] option `-t`
+	for more information.
+
 -R::
 --recursive::
 	Equivalent of --max-depth=-1 (infinite recursion).
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 014de05..392d273 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -515,16 +515,6 @@ static int ls_files(const char **argv, const char *prefix)
 	for (i = 0; i < exclude_list.nr; i++) {
 		add_exclude(exclude_list.items[i].string, "", 0, el, --exclude_args);
 	}
-	if (show_tag || show_valid_bit) {
-		tag_cached = "H ";
-		tag_unmerged = "M ";
-		tag_removed = "R ";
-		tag_modified = "C ";
-		tag_other = "? ";
-		tag_killed = "K ";
-		tag_skip_worktree = "S ";
-		tag_resolve_undo = "U ";
-	}
 	if (show_modified || show_others || show_deleted || (dir.flags & DIR_SHOW_IGNORED) || show_killed)
 		require_work_tree = 1;
 	if (show_unmerged && !porcelain)
@@ -578,6 +568,20 @@ static int ls_files(const char **argv, const char *prefix)
 	      show_killed || show_modified || show_resolve_undo))
 		show_cached = 1;
 
+	if (show_tag == -1)
+		show_tag = (show_cached + show_deleted + show_others +
+			    show_unmerged + show_killed + show_modified) > 1;
+	if (show_tag || show_valid_bit) {
+		tag_cached = porcelain ? "  " : "H ";
+		tag_unmerged = "M ";
+		tag_removed = "R ";
+		tag_modified = "C ";
+		tag_other = "? ";
+		tag_killed = "K ";
+		tag_skip_worktree = "S ";
+		tag_resolve_undo = "U ";
+	}
+
 	if (max_prefix)
 		prune_cache(max_prefix);
 	if (with_tree) {
@@ -727,6 +731,8 @@ int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
 			N_("show unmerged files in the output")),
 		OPT_SET_INT('R', "recursive", &max_depth,
 			    N_("shortcut for --max-depth=-1"), -1),
+		OPT_BOOL('t', "tag", &show_tag,
+			N_("identify the file status with tags")),
 		OPT__COLOR(&use_color, N_("show color")),
 		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
 		OPT_SET_INT('1', NULL, &colopts,
@@ -756,6 +762,7 @@ int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
 	setup_standard_excludes(&dir);
 	use_color = -1;
 	max_depth = 0;
+	show_tag = -1;
 
 	argc = parse_options(argc, argv, prefix, builtin_ls_options,
 			     ls_usage, 0);
-- 
1.9.1.345.ga1a145c

[PATCH v2 15/17] ls: sort output and remove duplicates

[Nguyễn Thái Ngọc Duy]

When you mix different file types, with ls-files you may get separate
listing. For example, "ls-files -cm" will show file "abc" twice: one
as part of cached list, one of modified list. With "ls" (and this
patch) they will be in a single sorted list (easier for the eye).

Duplicate entries are also removed. Note that display content is
compared, so if you have "-t" on, or you color file types differently,
you will get duplicate textual entries. This is good imo.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 30 +++++++++++++++++++++---------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 392d273..709d8b1 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -57,6 +57,13 @@ static const char *tag_modified = "";
 static const char *tag_skip_worktree = "";
 static const char *tag_resolve_undo = "";
 
+static int compare_output(const void *a_, const void *b_)
+{
+	const struct string_list_item *a = a_;
+	const struct string_list_item *b = b_;
+	return strcmp(a->util, b->util);
+}
+
 static void write_name(struct strbuf *sb, const char *name)
 {
 	/*
@@ -72,10 +79,12 @@ static void write_name(struct strbuf *sb, const char *name)
 		quote_path_relative(name, real_prefix, sb);
 }
 
-static void strbuf_fputs(struct strbuf *sb, FILE *fp)
+static void strbuf_fputs(struct strbuf *sb, const char *full_name, FILE *fp)
 {
-	if (column_active(colopts)) {
-		string_list_append(&output, strbuf_detach(sb, NULL));
+	if (column_active(colopts) || porcelain) {
+		struct string_list_item *it;
+		it = string_list_append(&output, strbuf_detach(sb, NULL));
+		it->util = (void*)full_name;
 		return;
 	}
 	fwrite(sb->buf, sb->len, 1, fp);
@@ -110,7 +119,7 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
 	strbuf_reset(&sb);
 	strbuf_addstr(&sb, tag);
 	write_dir_entry(&sb, ent);
-	strbuf_fputs(&sb, stdout);
+	strbuf_fputs(&sb, ent->name, stdout);
 }
 
 static void show_other_files(struct dir_struct *dir)
@@ -227,7 +236,7 @@ static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 			    ce_stage(ce));
 	}
 	write_ce_name(&sb, ce);
-	strbuf_fputs(&sb, stdout);
+	strbuf_fputs(&sb, ce->name, stdout);
 	if (debug_mode) {
 		const struct stat_data *sd = &ce->ce_stat_data;
 
@@ -535,7 +544,7 @@ static int ls_files(const char **argv, const char *prefix)
 		if (debug_mode)
 			die(_("--column and --debug are incompatible"));
 	}
-	if (column_active(colopts))
+	if (column_active(colopts) || porcelain)
 		line_terminator = 0;
 
 	if (require_work_tree && !is_inside_work_tree())
@@ -601,10 +610,13 @@ static int ls_files(const char **argv, const char *prefix)
 	if (show_resolve_undo)
 		show_ru_info();
 
-	if (column_active(colopts)) {
-		print_columns(&output, colopts, NULL);
-		string_list_clear(&output, 0);
+	if (porcelain) {
+		qsort(output.items, output.nr, sizeof(*output.items),
+		      compare_output);
+		string_list_remove_duplicates(&output, 0);
 	}
+	print_columns(&output, colopts, NULL);
+	string_list_clear(&output, 0);
 
 	if (ps_matched) {
 		int bad;
-- 
1.9.1.345.ga1a145c

[PATCH v2 16/17] ls: do not show duplicate cached entries

[Nguyễn Thái Ngọc Duy]

With the current show_files() "ls -tcm" will show

  foo.c
M foo.c

The first item is redundant. If "foo.c" is modified, we know it's in
the cache. Introduce show_files_compact to do that because ls-files is
plumbing and scripts may already depend on current display behavior.

Another difference in show_files_compact() is it does not show
skip-worktree (aka outside sparse checkout) entries anymore, which
makes sense in porcelain context.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 709d8b1..cd8e35c 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -337,6 +337,53 @@ static void show_files(struct dir_struct *dir)
 	}
 }
 
+static void show_files_compact(struct dir_struct *dir)
+{
+	int i;
+
+	/* For cached/deleted files we don't need to even do the readdir */
+	if (show_others || show_killed) {
+		if (!show_others)
+			dir->flags |= DIR_COLLECT_KILLED_ONLY;
+		fill_directory(dir, &pathspec);
+		if (show_others)
+			show_other_files(dir);
+		if (show_killed)
+			show_killed_files(dir);
+	}
+	if (!(show_cached || show_stage || show_deleted || show_modified))
+		return;
+	for (i = 0; i < active_nr; i++) {
+		const struct cache_entry *ce = active_cache[i];
+		struct stat st;
+		int err, shown = 0;
+		if ((dir->flags & DIR_SHOW_IGNORED) &&
+		    !ce_excluded(dir, ce))
+			continue;
+		if (show_unmerged && !ce_stage(ce))
+			continue;
+		if (ce->ce_flags & CE_UPDATE)
+			continue;
+		if (ce_skip_worktree(ce))
+			continue;
+		err = lstat(ce->name, &st);
+		if (show_deleted && err) {
+			show_ce_entry(tag_removed, ce);
+			shown = 1;
+		}
+		if (show_modified && ce_modified(ce, &st, 0)) {
+			show_ce_entry(tag_modified, ce);
+			shown = 1;
+		}
+		if (ce_stage(ce)) {
+			show_ce_entry(tag_unmerged, ce);
+			shown = 1;
+		}
+		if (!shown && show_cached)
+			show_ce_entry(tag_cached, ce);
+	}
+}
+
 /*
  * Prune the index to only contain stuff starting with "prefix"
  */
@@ -606,7 +653,10 @@ static int ls_files(const char **argv, const char *prefix)
 		refresh_index(&the_index, REFRESH_QUIET, &pathspec, NULL, NULL);
 		setup_pager();
 	}
-	show_files(&dir);
+	if (porcelain)
+		show_files_compact(&dir);
+	else
+		show_files(&dir);
 	if (show_resolve_undo)
 		show_ru_info();
 
-- 
1.9.1.345.ga1a145c

[PATCH v2 17/17] ls: show directories as well as files

[Nguyễn Thái Ngọc Duy]

The index does not store directories explicitly (except submodules) so
we have to figure them out from file list. The function
show_directories() deliberately generates duplicate directories and
expects the previous patch to remove duplicates.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index cd8e35c..7e50192 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -27,6 +27,7 @@ static int show_resolve_undo;
 static int show_modified;
 static int show_killed;
 static int show_valid_bit;
+static int show_dirs;
 static int line_terminator = '\n';
 static int debug_mode;
 static int use_color;
@@ -337,6 +338,43 @@ static void show_files(struct dir_struct *dir)
 	}
 }
 
+static void show_directories(const struct cache_entry *ce)
+{
+	static const char *last_directory;
+	struct strbuf sb = STRBUF_INIT;
+	const char *p = ce->name + prefix_len;
+	const char *sep;
+
+	if (last_directory) {
+		int len = strlen(last_directory);
+		if (!strncmp(ce->name, last_directory, len) &&
+		    ce->name[len] == '/')
+			p += len + 1;
+	}
+
+	while (*p && (sep = strchr(p, '/'))) {
+		struct strbuf sb2 = STRBUF_INIT;
+		strbuf_reset(&sb);
+		strbuf_add(&sb, ce->name, sep - ce->name);
+		p = sep + 1;
+		if (!match_pathspec(&pathspec, sb.buf, sb.len,
+				    prefix_len, NULL, 1))
+			continue;
+		write_name(&sb2, sb.buf);
+		if (want_color(use_color)) {
+			struct strbuf sb3 = STRBUF_INIT;
+			color_filename(&sb3, ce->name, sb2.buf, S_IFDIR, 1);
+			strbuf_release(&sb2);
+			sb2 = sb3;
+		}
+		if (show_tag)
+			strbuf_insert(&sb2, 0, tag_cached, strlen(tag_cached));
+		last_directory = strbuf_detach(&sb, NULL);
+		strbuf_fputs(&sb2, last_directory, NULL);
+		strbuf_release(&sb2);
+	}
+}
+
 static void show_files_compact(struct dir_struct *dir)
 {
 	int i;
@@ -357,6 +395,8 @@ static void show_files_compact(struct dir_struct *dir)
 		const struct cache_entry *ce = active_cache[i];
 		struct stat st;
 		int err, shown = 0;
+		if (show_dirs)
+			show_directories(ce);
 		if ((dir->flags & DIR_SHOW_IGNORED) &&
 		    !ce_excluded(dir, ce))
 			continue;
@@ -825,6 +865,7 @@ int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
 	use_color = -1;
 	max_depth = 0;
 	show_tag = -1;
+	show_dirs = 1;
 
 	argc = parse_options(argc, argv, prefix, builtin_ls_options,
 			     ls_usage, 0);
-- 
1.9.1.345.ga1a145c

Re: [PATCH v2 06/17] ls-files: add --color to highlight file names

[Eric Sunshine]

On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
> ---
>  Documentation/git-ls-files.txt |  9 +++++++++
>  builtin/ls-files.c             | 38 +++++++++++++++++++++++++++++++++++---
>  2 files changed, 44 insertions(+), 3 deletions(-)
>
> diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
> index c0856a6..5c1b7f3 100644
> --- a/Documentation/git-ls-files.txt
> +++ b/Documentation/git-ls-files.txt
> @@ -147,6 +147,15 @@ a space) at the start of each line:
>         possible for manual inspection; the exact format may change at
>         any time.
>
> +--color[=<when>]::
> +       Color file names. The value must be always (default), never,
> +       or auto.

Here, the default is "always"...

> +--no-color::
> +       Turn off coloring, even when the configuration file gives the
> +       default to color output, same as `--color=never`. This is the
> +       default.

But, here the default is "never".

> +
>  \--::
>         Do not interpret any more arguments as options.
>
> diff --git a/builtin/ls-files.c b/builtin/ls-files.c
> index 6e30592..2857b38 100644
> --- a/builtin/ls-files.c
> +++ b/builtin/ls-files.c
> @@ -14,6 +14,7 @@
>  #include "resolve-undo.h"
>  #include "string-list.h"
>  #include "pathspec.h"
> +#include "color.h"
>
>  static int abbrev;
>  static int show_deleted;
> @@ -27,6 +28,7 @@ static int show_killed;
>  static int show_valid_bit;
>  static int line_terminator = '\n';
>  static int debug_mode;
> +static int use_color;
>
>  static const char *prefix;
>  static int max_prefix_len;
> @@ -60,7 +62,6 @@ static void write_name(struct strbuf *sb, const char *name)
>                 strbuf_release(&sb2);
>         } else
>                 quote_path_relative(name, real_prefix, sb);
> -       strbuf_addch(sb, line_terminator);
>  }
>
>  static void strbuf_fputs(struct strbuf *sb, FILE *fp)
> @@ -68,6 +69,21 @@ static void strbuf_fputs(struct strbuf *sb, FILE *fp)
>         fwrite(sb->buf, sb->len, 1, fp);
>  }
>
> +static void write_dir_entry(struct strbuf *sb, const struct dir_entry *ent)
> +{
> +       struct strbuf quoted = STRBUF_INIT;
> +       struct stat st;
> +       if (stat(ent->name, &st))
> +               st.st_mode = 0;
> +       write_name(&quoted, ent->name);
> +       if (want_color(use_color))
> +               color_filename(sb, ent->name, quoted.buf, st.st_mode, 1);
> +       else
> +               strbuf_addbuf(sb, &quoted);
> +       strbuf_addch(sb, line_terminator);
> +       strbuf_release(&quoted);
> +}
> +
>  static void show_dir_entry(const char *tag, struct dir_entry *ent)
>  {
>         static struct strbuf sb = STRBUF_INIT;
> @@ -81,7 +97,7 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
>
>         strbuf_reset(&sb);
>         strbuf_addstr(&sb, tag);
> -       write_name(&sb, ent->name);
> +       write_dir_entry(&sb, ent);
>         strbuf_fputs(&sb, stdout);
>  }
>
> @@ -146,6 +162,18 @@ static void show_killed_files(struct dir_struct *dir)
>         }
>  }
>
> +static void write_ce_name(struct strbuf *sb, const struct cache_entry *ce)
> +{
> +       struct strbuf quoted = STRBUF_INIT;
> +       write_name(&quoted, ce->name);
> +       if (want_color(use_color))
> +               color_filename(sb, ce->name, quoted.buf, ce->ce_mode, 1);
> +       else
> +               strbuf_addbuf(sb, &quoted);
> +       strbuf_addch(sb, line_terminator);
> +       strbuf_release(&quoted);
> +}
> +
>  static void show_ce_entry(const char *tag, const struct cache_entry *ce)
>  {
>         static struct strbuf sb = STRBUF_INIT;
> @@ -186,7 +214,7 @@ static void show_ce_entry(const char *tag, const struct cache_entry *ce)
>                             find_unique_abbrev(ce->sha1,abbrev),
>                             ce_stage(ce));
>         }
> -       write_name(&sb, ce->name);
> +       write_ce_name(&sb, ce);
>         strbuf_fputs(&sb, stdout);
>         if (debug_mode) {
>                 const struct stat_data *sd = &ce->ce_stat_data;
> @@ -523,6 +551,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>                         N_("if any <file> is not in the index, treat this as an error")),
>                 OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
>                         N_("pretend that paths removed since <tree-ish> are still present")),
> +               OPT__COLOR(&use_color, N_("show color")),
>                 OPT__ABBREV(&abbrev),
>                 OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
>                 OPT_END()
> @@ -570,6 +599,9 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>         if (require_work_tree && !is_inside_work_tree())
>                 setup_work_tree();
>
> +       if (want_color(use_color))
> +               parse_ls_color();
> +
>         parse_pathspec(&pathspec, 0,
>                        PATHSPEC_PREFER_CWD |
>                        PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
> --
> 1.9.1.345.ga1a145c
>
> --
> To unsubscribe from this list: send the line "unsubscribe git" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH v2 03/17] ls_colors.c: add function to color a file name

[Eric Sunshine]

On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
> Tthe new function is based on print_color_indicator() from commit

s/Tthe/The/

> 7326d1f1a67edf21947ae98194f98c38b6e9e527 in coreutils.git.
>
> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
> ---
>  color.h     |  2 ++
>  ls_colors.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 68 insertions(+)
>
> diff --git a/color.h b/color.h
> index 640fc48..398369a 100644
> --- a/color.h
> +++ b/color.h
> @@ -94,5 +94,7 @@ void color_print_strbuf(FILE *fp, const char *color, const struct strbuf *sb);
>  int color_is_nil(const char *color);
>
>  void parse_ls_color(void);
> +void color_filename(struct strbuf *sb, const char *name,
> +                   const char *display_name, mode_t mode, int linkok);
>
>  #endif /* COLOR_H */
> diff --git a/ls_colors.c b/ls_colors.c
> index cef5a92..1125329 100644
> --- a/ls_colors.c
> +++ b/ls_colors.c
> @@ -422,3 +422,69 @@ void parse_ls_color(void)
>                 color_symlink_as_referent = 1;
>         git_config(ls_colors_config, NULL);
>  }
> +
> +void color_filename(struct strbuf *sb, const char *name,
> +                   const char *display_name, mode_t mode, int linkok)
> +{
> +       int type;
> +       struct color_ext_type *ext;     /* Color extension */
> +
> +       if (S_ISREG (mode)) {
> +               type = LS_FL;
> +               if ((mode & S_ISUID) != 0)
> +                       type = LS_SU;
> +               else if ((mode & S_ISGID) != 0)
> +                       type = LS_SG;
> +               else if ((mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0)
> +                       type = LS_EX;
> +       } else if (S_ISDIR (mode)) {
> +               if ((mode & S_ISVTX) && (mode & S_IWOTH))
> +                       type = LS_TW;
> +               else if ((mode & S_IWOTH) != 0)
> +                       type = LS_OW;
> +               else if ((mode & S_ISVTX) != 0)
> +                       type = LS_ST;
> +               else
> +                       type = LS_DI;
> +       } else if (S_ISLNK (mode))
> +               type = (!linkok && *ls_colors[LS_OR]) ? LS_OR : LS_LN;
> +       else if (S_ISFIFO (mode))
> +               type = LS_PI;
> +       else if (S_ISSOCK (mode))
> +               type = LS_SO;
> +       else if (S_ISBLK (mode))
> +               type = LS_BD;
> +       else if (S_ISCHR (mode))
> +               type = LS_CD;
> +#ifdef S_ISDOOR
> +       else if (S_ISDOOR (mode))
> +               type = LS_DO;
> +#endif
> +       else
> +               /* Classify a file of some other type as C_ORPHAN.  */
> +               type = LS_OR;
> +
> +       /* Check the file's suffix only if still classified as C_FILE.  */
> +       ext = NULL;
> +       if (type == LS_FL) {
> +               /* Test if NAME has a recognized suffix.  */
> +               size_t len = strlen(name);
> +               const char *p = name + len;             /* Pointer to final \0.  */
> +               for (ext = color_ext_list; ext != NULL; ext = ext->next) {
> +                       if (ext->ext.len <= len &&
> +                           !strncmp(p - ext->ext.len, ext->ext.string, ext->ext.len))
> +                               break;
> +               }
> +       }
> +
> +       if (display_name)
> +               name = display_name;
> +       if (ext)
> +               strbuf_addf(sb, "\033[%.*sm%s%s",
> +                           (int)ext->seq.len, ext->seq.string,
> +                           name, GIT_COLOR_RESET);
> +       else if (*ls_colors[type])
> +               strbuf_addf(sb, "%s%s%s", ls_colors[type], name, GIT_COLOR_RESET);
> +       else
> +               strbuf_addstr(sb, name);
> +}
> --
> 1.9.1.345.ga1a145c
>
> --
> To unsubscribe from this list: send the line "unsubscribe git" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH v2 05/17] ls-files: buffer full item in strbuf before printing

[Eric Sunshine]

On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
> Buffering so that we can manipulate the strings (e.g. coloring)
> further before finally printing them.
>
> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
> ---
>  builtin/ls-files.c | 48 +++++++++++++++++++++++++++++++++++-------------
>  1 file changed, 35 insertions(+), 13 deletions(-)
>
> diff --git a/builtin/ls-files.c b/builtin/ls-files.c
> index 47c3880..6e30592 100644
> --- a/builtin/ls-files.c
> +++ b/builtin/ls-files.c
> @@ -47,18 +47,30 @@ static const char *tag_modified = "";
>  static const char *tag_skip_worktree = "";
>  static const char *tag_resolve_undo = "";
>
> -static void write_name(const char *name)
> +static void write_name(struct strbuf *sb, const char *name)
>  {
>         /*
>          * With "--full-name", prefix_len=0; this caller needs to pass
>          * an empty string in that case (a NULL is good for "").
>          */
> -       write_name_quoted_relative(name, prefix_len ? prefix : NULL,
> -                                  stdout, line_terminator);
> +       const char *real_prefix = prefix_len ? prefix : NULL;
> +       if (!line_terminator) {
> +               struct strbuf sb2 = STRBUF_INIT;
> +               strbuf_addstr(sb, relative_path(name, real_prefix, &sb2));
> +               strbuf_release(&sb2);
> +       } else
> +               quote_path_relative(name, real_prefix, sb);
> +       strbuf_addch(sb, line_terminator);
> +}
> +
> +static void strbuf_fputs(struct strbuf *sb, FILE *fp)
> +{
> +       fwrite(sb->buf, sb->len, 1, fp);
>  }
>
>  static void show_dir_entry(const char *tag, struct dir_entry *ent)
>  {
> +       static struct strbuf sb = STRBUF_INIT;
>         int len = max_prefix_len;
>
>         if (len >= ent->len)
> @@ -67,8 +79,10 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
>         if (!dir_path_match(ent, &pathspec, len, ps_matched))
>                 return;
>
> -       fputs(tag, stdout);
> -       write_name(ent->name);
> +       strbuf_reset(&sb);
> +       strbuf_addstr(&sb, tag);
> +       write_name(&sb, ent->name);
> +       strbuf_fputs(&sb, stdout);

strbuf_release(&sb);

>  }
>
>  static void show_other_files(struct dir_struct *dir)
> @@ -134,6 +148,7 @@ static void show_killed_files(struct dir_struct *dir)
>
>  static void show_ce_entry(const char *tag, const struct cache_entry *ce)
>  {
> +       static struct strbuf sb = STRBUF_INIT;
>         int len = max_prefix_len;
>
>         if (len >= ce_namelen(ce))
> @@ -161,16 +176,18 @@ static void show_ce_entry(const char *tag, const struct cache_entry *ce)
>                 tag = alttag;
>         }
>
> +       strbuf_reset(&sb);

'sb' is empty at this point. Why reset it?

>         if (!show_stage) {
> -               fputs(tag, stdout);
> +               strbuf_addstr(&sb, tag);
>         } else {
> -               printf("%s%06o %s %d\t",
> -                      tag,
> -                      ce->ce_mode,
> -                      find_unique_abbrev(ce->sha1,abbrev),
> -                      ce_stage(ce));
> +               strbuf_addf(&sb, "%s%06o %s %d\t",
> +                           tag,
> +                           ce->ce_mode,
> +                           find_unique_abbrev(ce->sha1,abbrev),
> +                           ce_stage(ce));
>         }
> -       write_name(ce->name);
> +       write_name(&sb, ce->name);
> +       strbuf_fputs(&sb, stdout);

strbuf_release(&sb);

>         if (debug_mode) {
>                 const struct stat_data *sd = &ce->ce_stat_data;
>
> @@ -206,7 +223,12 @@ static void show_ru_info(void)
>                         printf("%s%06o %s %d\t", tag_resolve_undo, ui->mode[i],
>                                find_unique_abbrev(ui->sha1[i], abbrev),
>                                i + 1);
> -                       write_name(path);
> +                       /*
> +                        * With "--full-name", prefix_len=0; this caller needs to pass
> +                        * an empty string in that case (a NULL is good for "").
> +                        */
> +                       write_name_quoted_relative(path, prefix_len ? prefix : NULL,
> +                                                  stdout, line_terminator);
>                 }
>         }
>  }
> --
> 1.9.1.345.ga1a145c

Re: [PATCH v2 07/17] ls-files: add --column

[Eric Sunshine]

On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
> ---
>  Documentation/git-ls-files.txt |  6 ++++++
>  builtin/ls-files.c             | 25 +++++++++++++++++++++++++
>  2 files changed, 31 insertions(+)
>
> diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
> index 5c1b7f3..cd52461 100644
> --- a/Documentation/git-ls-files.txt
> +++ b/Documentation/git-ls-files.txt
> @@ -156,6 +156,12 @@ a space) at the start of each line:
>         default to color output, same as `--color=never`. This is the
>         default.
>
> +--column[=<options>]::
> +--no-column::
> +       Display files in columns. See configuration variable column.ui
> +       for option syntax.`--column` and `--no-column` without options

Missing space after period.

> +       are equivalent to 'always' and 'never' respectively.
> +
>  \--::
>         Do not interpret any more arguments as options.
>
> diff --git a/builtin/ls-files.c b/builtin/ls-files.c
> index 2857b38..335d3b0 100644
> --- a/builtin/ls-files.c
> +++ b/builtin/ls-files.c
> @@ -15,6 +15,7 @@
>  #include "string-list.h"
>  #include "pathspec.h"
>  #include "color.h"
> +#include "column.h"
>
>  static int abbrev;
>  static int show_deleted;
> @@ -29,6 +30,7 @@ static int show_valid_bit;
>  static int line_terminator = '\n';
>  static int debug_mode;
>  static int use_color;
> +static unsigned int colopts;
>
>  static const char *prefix;
>  static int max_prefix_len;
> @@ -39,6 +41,7 @@ static char *ps_matched;
>  static const char *with_tree;
>  static int exc_given;
>  static int exclude_args;
> +static struct string_list output = STRING_LIST_INIT_NODUP;
>
>  static const char *tag_cached = "";
>  static const char *tag_unmerged = "";
> @@ -66,6 +69,10 @@ static void write_name(struct strbuf *sb, const char *name)
>
>  static void strbuf_fputs(struct strbuf *sb, FILE *fp)
>  {
> +       if (column_active(colopts)) {
> +               string_list_append(&output, strbuf_detach(sb, NULL));
> +               return;
> +       }
>         fwrite(sb->buf, sb->len, 1, fp);
>  }
>
> @@ -552,6 +559,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>                 OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
>                         N_("pretend that paths removed since <tree-ish> are still present")),
>                 OPT__COLOR(&use_color, N_("show color")),
> +               OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
>                 OPT__ABBREV(&abbrev),
>                 OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
>                 OPT_END()
> @@ -596,6 +604,18 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>         if (dir.exclude_per_dir)
>                 exc_given = 1;
>
> +       finalize_colopts(&colopts, -1);
> +       if (explicitly_enable_column(colopts)) {
> +               if (!line_terminator)
> +                       die(_("--column and -z are incompatible"));
> +               if (show_resolve_undo)
> +                       die(_("--column and --resolve-undo are incompatible"));
> +               if (debug_mode)
> +                       die(_("--column and --debug are incompatible"));
> +       }
> +       if (column_active(colopts))
> +               line_terminator = 0;
> +
>         if (require_work_tree && !is_inside_work_tree())
>                 setup_work_tree();
>
> @@ -638,6 +658,11 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>         if (show_resolve_undo)
>                 show_ru_info();
>
> +       if (column_active(colopts)) {
> +               print_columns(&output, colopts, NULL);
> +               string_list_clear(&output, 0);
> +       }
> +
>         if (ps_matched) {
>                 int bad;
>                 bad = report_path_error(ps_matched, &pathspec, prefix);
> --
> 1.9.1.345.ga1a145c
>
> --
> To unsubscribe from this list: send the line "unsubscribe git" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH v2 08/17] ls-files: support --max-depth

[Eric Sunshine]

On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
> ---
>  Documentation/git-ls-files.txt | 7 +++++++
>  builtin/ls-files.c             | 7 +++++++
>  2 files changed, 14 insertions(+)
>
> diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
> index cd52461..3c022eb 100644
> --- a/Documentation/git-ls-files.txt
> +++ b/Documentation/git-ls-files.txt
> @@ -162,6 +162,13 @@ a space) at the start of each line:
>         for option syntax.`--column` and `--no-column` without options
>         are equivalent to 'always' and 'never' respectively.
>
> +--max-depth <depth>::

Other options in this file are documented as:

    --max-depth=<depth>::

> +       For each <pathspec> given on command line, descend at most <depth>
> +       levels of directories. A negative value means no limit.
> +       This option is ignored if <pathspec> contains active wildcards.
> +       In other words if "a*" matches a directory named "a*",
> +       "*" is matched literally so --max-depth is still effective.

Would it be worthwhile to mention the default?

> +
>  \--::
>         Do not interpret any more arguments as options.
>
> diff --git a/builtin/ls-files.c b/builtin/ls-files.c
> index 335d3b0..8eef423 100644
> --- a/builtin/ls-files.c
> +++ b/builtin/ls-files.c
> @@ -503,6 +503,7 @@ static int option_parse_exclude_standard(const struct option *opt,
>  int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>  {
>         int require_work_tree = 0, show_tag = 0, i;
> +       int max_depth = -1;
>         const char *max_prefix;
>         struct dir_struct dir;
>         struct exclude_list *el;
> @@ -560,6 +561,9 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>                         N_("pretend that paths removed since <tree-ish> are still present")),
>                 OPT__COLOR(&use_color, N_("show color")),
>                 OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
> +               { OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
> +                       N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
> +                       NULL, 1 },
>                 OPT__ABBREV(&abbrev),
>                 OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
>                 OPT_END()
> @@ -624,8 +628,11 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>
>         parse_pathspec(&pathspec, 0,
>                        PATHSPEC_PREFER_CWD |
> +                      (max_depth != -1 ? PATHSPEC_MAXDEPTH_VALID : 0) |
>                        PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
>                        prefix, argv);
> +       pathspec.max_depth = max_depth;
> +       pathspec.recursive = 1;
>
>         /* Find common prefix for all pathspec's */
>         max_prefix = common_prefix(&pathspec);
> --
> 1.9.1.345.ga1a145c

Re: [PATCH v2 10/17] Add git-ls, a user friendly version of ls-files and more

[Eric Sunshine]

On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
> This is more user friendly version of ls-files:
>
> * it's automatically colored and columnized
> * it refreshes the index like all porcelain commands
> * it defaults to non-recursive behavior like ls
> * :(glob) is on by default so '*.c' means a.c but not a/b.c, use
>   '**/*.c' for that.
> * auto pager
>
> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
> ---
>  .gitignore                     |  1 +
>  Documentation/config.txt       | 10 ++++++
>  Documentation/git-ls.txt (new) | 82 ++++++++++++++++++++++++++++++++++++++++++
>  Makefile                       |  1 +
>  builtin.h                      |  1 +
>  builtin/ls-files.c             | 70 ++++++++++++++++++++++++++++++++++++
>  command-list.txt               |  1 +
>  git.c                          |  1 +
>  8 files changed, 167 insertions(+)
>  create mode 100644 Documentation/git-ls.txt
>
> diff --git a/.gitignore b/.gitignore
> index dc600f9..f91af81 100644
> --- a/.gitignore
> +++ b/.gitignore
> @@ -76,6 +76,7 @@
>  /git-init-db
>  /git-instaweb
>  /git-log
> +/git-ls
>  /git-ls-files
>  /git-ls-remote
>  /git-ls-tree
> diff --git a/Documentation/config.txt b/Documentation/config.txt
> index 6bca55e..87a6dcf 100644
> --- a/Documentation/config.txt
> +++ b/Documentation/config.txt
> @@ -909,6 +909,12 @@ color.status.<slot>::
>         to red). The values of these variables may be specified as in
>         color.branch.<slot>.
>
> +color.ls::
> +       A boolean to enable/disable color in the output of
> +       linkgit:git-ls[1]. May be set to `always`, `false` (or
> +       `never`) or `auto` (or `true`), in which case colors are used
> +       only when the output is to a terminal. Defaults to false.
> +
>  color.ls.<slot>::
>         Use customized color for file name colorization. If not set
>         and the environment variable LS_COLORS is set, color settings
> @@ -981,6 +987,10 @@ column.clean::
>         Specify the layout when list items in `git clean -i`, which always
>         shows files and directories in columns. See `column.ui` for details.
>
> +column.ls::
> +       Specify whether to output tag listing in `git ls` in columns.
> +       See `column.ui` for details.
> +
>  column.status::
>         Specify whether to output untracked files in `git status` in columns.
>         See `column.ui` for details.
> diff --git a/Documentation/git-ls.txt b/Documentation/git-ls.txt
> new file mode 100644
> index 0000000..67ca522
> --- /dev/null
> +++ b/Documentation/git-ls.txt
> @@ -0,0 +1,82 @@
> +git-ls(1)
> +===============
> +
> +NAME
> +----
> +git-ls - List files
> +
> +SYNOPSIS
> +--------
> +[verse]
> +'git ls' (--[cached|deleted|others|ignored|unmerged|modified])*
> +       (-[c|d|o|i|s|u|m])*

Don't you have [...] and (...) transposed? The way it's written, "-"
and "--" are valid optional arguments. You probably meant:

    [--(cached|deleted|x|y|z)]...
    [-(c|d|x|y|z)]...

> +       [options] [<pathspec>...]

However, you also have the generic [options] here, which covers all of
the above. It probably would make sense to just use [options] and drop
the enumerated list.

> +DESCRIPTION
> +-----------
> +List files (by default in current working directory) that are in the
> +index. Depending on the chosen options, maybe only modified files in
> +working tree are shown, or untracked files...
> +
> +OPTIONS
> +-------
> +-c::
> +--cached::
> +       Show cached files in the output (default)

"in the output" is superfluous. Perhaps drop it from each of the descriptions.

> +-d::
> +--deleted::
> +       Show deleted files in the output

Is this showing only deleted file or including them in the list of
files otherwise displayed? It's not clear from the description. Same
question for the other options.

> +-m::
> +--modified::
> +       Show modified files in the output
> +
> +-o::
> +--others::
> +       Show other (i.e. untracked) files in the output
> +
> +-i::
> +--ignored::
> +       Show only ignored files in the output. When showing files in the
> +       index, print only those matched by an exclude pattern. When
> +       showing "other" files, show only those matched by an exclude
> +       pattern.
> +
> +-u::
> +--unmerged::
> +       Show unmerged files in the output (forces --stage)

This is the only mention of --stage in this document. Not sure what
it's trying to say.

> +--color[=<when>]::
> +       Color file names. The value must be always (default), never,
> +       or auto.

Same problem mentioned in the other patch. Default is "always"...

> +
> +--no-color::
> +       Turn off coloring, even when the configuration file gives the
> +       default to color output, same as `--color=never`. This is the
> +       default.

But default is also "never".

> +
> +--column[=<options>]::
> +--no-column::
> +       Display files in columns. See configuration variable column.ui
> +       for option syntax.`--column` and `--no-column` without options

Missing space after period.

More below.

> +       are equivalent to 'always' and 'never' respectively.
> +
> +--max-depth <depth>::
> +       For each <pathspec> given on command line, descend at most <depth>
> +       levels of directories. A negative value means no limit.
> +       This option is ignored if <pathspec> contains active wildcards.
> +       In other words if "a*" matches a directory named "a*",
> +       "*" is matched literally so --max-depth is still effective.
> +
> +<pathspec>::
> +       Files to show. :(glob) magic is enabled and recursion disabled
> +       by default.
> +
> +SEE ALSO
> +--------
> +linkgit:git-ls-files[1]
> +
> +GIT
> +---
> +Part of the linkgit:git[1] suite
> diff --git a/Makefile b/Makefile
> index f6a6e14..b0bc40a 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -584,6 +584,7 @@ BUILT_INS += git-cherry-pick$X
>  BUILT_INS += git-format-patch$X
>  BUILT_INS += git-fsck-objects$X
>  BUILT_INS += git-init$X
> +BUILT_INS += git-ls$X
>  BUILT_INS += git-merge-subtree$X
>  BUILT_INS += git-show$X
>  BUILT_INS += git-stage$X
> diff --git a/builtin.h b/builtin.h
> index c47c110..177aa7d 100644
> --- a/builtin.h
> +++ b/builtin.h
> @@ -75,6 +75,7 @@ extern int cmd_index_pack(int argc, const char **argv, const char *prefix);
>  extern int cmd_init_db(int argc, const char **argv, const char *prefix);
>  extern int cmd_log(int argc, const char **argv, const char *prefix);
>  extern int cmd_log_reflog(int argc, const char **argv, const char *prefix);
> +extern int cmd_ls(int argc, const char **argv, const char *prefix);
>  extern int cmd_ls_files(int argc, const char **argv, const char *prefix);
>  extern int cmd_ls_tree(int argc, const char **argv, const char *prefix);
>  extern int cmd_ls_remote(int argc, const char **argv, const char *prefix);
> diff --git a/builtin/ls-files.c b/builtin/ls-files.c
> index 20ca3f2..74eb3c2 100644
> --- a/builtin/ls-files.c
> +++ b/builtin/ls-files.c
> @@ -33,6 +33,7 @@ static int use_color;
>  static unsigned int colopts;
>  static int max_depth = -1;
>  static int show_tag;
> +static int porcelain;
>
>  static const char *prefix;
>  static int max_prefix_len;
> @@ -588,6 +589,10 @@ static int ls_files(const char **argv, const char *prefix)
>                         die("ls-files --with-tree is incompatible with -s or -u");
>                 overlay_tree_on_cache(with_tree, max_prefix);
>         }
> +       if (porcelain) {
> +               refresh_index(&the_index, REFRESH_QUIET, &pathspec, NULL, NULL);
> +               setup_pager();
> +       }
>         show_files(&dir);
>         if (show_resolve_undo)
>                 show_ru_info();
> @@ -687,3 +692,68 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>                         ls_files_usage, 0);
>         return ls_files(argv, prefix);
>  }
> +
> +static const char * const ls_usage[] = {
> +       N_("git ls [options] [<file>...]"),
> +       NULL
> +};
> +
> +static int git_ls_config(const char *var, const char *value, void *cb)
> +{
> +       if (starts_with(var, "column."))
> +               return git_column_config(var, value, "ls", &colopts);
> +       if (!strcmp(var, "color.ls")) {
> +               use_color = git_config_colorbool(var, value);
> +               return 0;
> +       }
> +       return git_color_default_config(var, value, cb);
> +}
> +
> +int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
> +{
> +       struct option builtin_ls_options[] = {
> +               OPT_BOOL('c', "cached", &show_cached,
> +                       N_("show cached files in the output (default)")),

Ditto regarding the unnecessary and repetitive "in the output".

> +               OPT_BOOL('d', "deleted", &show_deleted,
> +                       N_("show deleted files in the output")),
> +               OPT_BOOL('m', "modified", &show_modified,
> +                       N_("show modified files in the output")),
> +               OPT_BOOL('o', "others", &show_others,
> +                       N_("show other files in the output")),
> +               OPT_BIT('i', "ignored", &dir.flags,
> +                       N_("show ignored files in the output"),
> +                       DIR_SHOW_IGNORED),
> +               OPT_BOOL('u', "unmerged", &show_unmerged,
> +                       N_("show unmerged files in the output")),
> +               OPT__COLOR(&use_color, N_("show color")),
> +               OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
> +               { OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
> +                       N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
> +                       NULL, 1 },
> +               OPT__ABBREV(&abbrev),
> +               OPT_END()
> +       };
> +
> +       if (argc == 2 && !strcmp(argv[1], "-h"))
> +               usage_with_options(ls_usage, builtin_ls_options);
> +
> +       prefix = cmd_prefix;
> +       if (prefix)
> +               prefix_len = strlen(prefix);
> +       git_config(git_ls_config, NULL);
> +
> +       if (read_cache() < 0)
> +               die("index file corrupt");
> +
> +       /* default setup */
> +       porcelain = 1;
> +       setenv(GIT_GLOB_PATHSPECS_ENVIRONMENT, "1", 1);
> +       exc_given = 1;
> +       setup_standard_excludes(&dir);
> +       use_color = -1;
> +       max_depth = 0;
> +
> +       argc = parse_options(argc, argv, prefix, builtin_ls_options,
> +                            ls_usage, 0);
> +       return ls_files(argv, prefix);
> +}
> diff --git a/command-list.txt b/command-list.txt
> index cf36c3d..89e5cef 100644
> --- a/command-list.txt
> +++ b/command-list.txt
> @@ -64,6 +64,7 @@ git-init                                mainporcelain common
>  git-instaweb                            ancillaryinterrogators
>  gitk                                    mainporcelain
>  git-log                                 mainporcelain common
> +git-ls                                  mainporcelain
>  git-ls-files                            plumbinginterrogators
>  git-ls-remote                           plumbinginterrogators
>  git-ls-tree                             plumbinginterrogators
> diff --git a/git.c b/git.c
> index 9efd1a3..682a81e 100644
> --- a/git.c
> +++ b/git.c
> @@ -381,6 +381,7 @@ static struct cmd_struct commands[] = {
>         { "init", cmd_init_db },
>         { "init-db", cmd_init_db },
>         { "log", cmd_log, RUN_SETUP },
> +       { "ls", cmd_ls, RUN_SETUP },
>         { "ls-files", cmd_ls_files, RUN_SETUP },
>         { "ls-remote", cmd_ls_remote, RUN_SETUP_GENTLY },
>         { "ls-tree", cmd_ls_tree, RUN_SETUP },
> --
> 1.9.1.345.ga1a145c

Re: [PATCH v2 06/17] ls-files: add --color to highlight file names

[Duy Nguyen]

On Thu, Mar 27, 2014 at 2:13 AM, Eric Sunshine <sunshine@sunshineco.com> wrote:
> On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
>> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
>> ---
>>  Documentation/git-ls-files.txt |  9 +++++++++
>>  builtin/ls-files.c             | 38 +++++++++++++++++++++++++++++++++++---
>>  2 files changed, 44 insertions(+), 3 deletions(-)
>>
>> diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
>> index c0856a6..5c1b7f3 100644
>> --- a/Documentation/git-ls-files.txt
>> +++ b/Documentation/git-ls-files.txt
>> @@ -147,6 +147,15 @@ a space) at the start of each line:
>>         possible for manual inspection; the exact format may change at
>>         any time.
>>
>> +--color[=<when>]::
>> +       Color file names. The value must be always (default), never,
>> +       or auto.
>
> Here, the default is "always"...

These (.txt changes in other patches as well) are mostly copy and
paste from existing .txt files. You may want to grep through and fix
other places as well, in a separate series.

>
>> +--no-color::
>> +       Turn off coloring, even when the configuration file gives the
>> +       default to color output, same as `--color=never`. This is the
>> +       default.
>
> But, here the default is "never".

What I mean is color is turned off by default for ls-files (in
contrast, ls has color on by default). The default 'always' means that
if you write --color without the <when> part, then it's
--color=always. How do I phrase to make it clear?
-- 
Duy

Re: [PATCH v2 05/17] ls-files: buffer full item in strbuf before printing

[Duy Nguyen]

On Thu, Mar 27, 2014 at 2:22 AM, Eric Sunshine <sunshine@sunshineco.com> wrote:
>>  static void show_dir_entry(const char *tag, struct dir_entry *ent)
>>  {
>> +       static struct strbuf sb = STRBUF_INIT;
>>         int len = max_prefix_len;
>>
>>         if (len >= ent->len)
>> @@ -67,8 +79,10 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
>>         if (!dir_path_match(ent, &pathspec, len, ps_matched))
>>                 return;
>>
>> -       fputs(tag, stdout);
>> -       write_name(ent->name);
>> +       strbuf_reset(&sb);
>> +       strbuf_addstr(&sb, tag);
>> +       write_name(&sb, ent->name);
>> +       strbuf_fputs(&sb, stdout);
>
> strbuf_release(&sb);

Not strictly necessary because sb is static and will be reset at the
next call. I just want to lower the number of allocation (write_name
allocates some more). It may be a premature optimization though.

The same for changes in show_ce_entry().
-- 
Duy

Re: [PATCH v2 05/17] ls-files: buffer full item in strbuf before printing

[Eric Sunshine]

On Wed, Mar 26, 2014 at 7:18 PM, Duy Nguyen <pclouds@gmail.com> wrote:
> On Thu, Mar 27, 2014 at 2:22 AM, Eric Sunshine <sunshine@sunshineco.com> wrote:
>>>  static void show_dir_entry(const char *tag, struct dir_entry *ent)
>>>  {
>>> +       static struct strbuf sb = STRBUF_INIT;
>>>         int len = max_prefix_len;
>>>
>>>         if (len >= ent->len)
>>> @@ -67,8 +79,10 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
>>>         if (!dir_path_match(ent, &pathspec, len, ps_matched))
>>>                 return;
>>>
>>> -       fputs(tag, stdout);
>>> -       write_name(ent->name);
>>> +       strbuf_reset(&sb);
>>> +       strbuf_addstr(&sb, tag);
>>> +       write_name(&sb, ent->name);
>>> +       strbuf_fputs(&sb, stdout);
>>
>> strbuf_release(&sb);
>
> Not strictly necessary because sb is static and will be reset at the
> next call. I just want to lower the number of allocation (write_name
> allocates some more). It may be a premature optimization though.

Ah, yes. I noted the 'static' on my initial read-through but had
forgotten about it by the time I finally got to a computer with which
I could send plain-text email. Sorry for the noise.

> The same for changes in show_ce_entry().
> --
> Duy

Re: [PATCH 7/8] ls-files: support --max-depth

[Duy Nguyen]

On Tue, Mar 25, 2014 at 6:15 PM, Duy Nguyen <pclouds@gmail.com> wrote:
> On Tue, Mar 25, 2014 at 3:55 PM, Matthieu Moy
> <matthieu.moy@grenoble-inp.fr> wrote:
>> ----- Original Message -----
>>> The use case in mind is --max-depth=0 to stop recursion. With this we can do
>>>
>>> git config --global alias.ls 'ls-files --column --color --max-depth=0'
>>>
>>> and have "git ls" with an output very similar to GNU ls.
>>
>> One big difference though: your "git ls" does not show directories. I understand that this is easier to implement, but from the user point of view it resulted in a "wtf" from me running "git ls" in a repository containing essentially directories, and seeing just a README file in the output.
>
> I was hoping you didn't notice :) It'll be more difficult but not impossible.
>
>> Ideally (for me), directories should be shown with a trailing / like "ls -F" does.
>
> I'd rather go with no trailing slash by default and add -F (which
> seems to be more than just '/')

And we need a new indicator for submodules when -F is used. I think it
should be different than '/'. I randomly picked '&' for now. Any
suggestions welcome.
-- 
Duy

Re: [PATCH v2 06/17] ls-files: add --color to highlight file names

[Eric Sunshine]

On Wed, Mar 26, 2014 at 7:15 PM, Duy Nguyen <pclouds@gmail.com> wrote:
> On Thu, Mar 27, 2014 at 2:13 AM, Eric Sunshine <sunshine@sunshineco.com> wrote:
>> On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
>>> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
>>> ---
>>>  Documentation/git-ls-files.txt |  9 +++++++++
>>>  builtin/ls-files.c             | 38 +++++++++++++++++++++++++++++++++++---
>>>  2 files changed, 44 insertions(+), 3 deletions(-)
>>>
>>> diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
>>> index c0856a6..5c1b7f3 100644
>>> --- a/Documentation/git-ls-files.txt
>>> +++ b/Documentation/git-ls-files.txt
>>> @@ -147,6 +147,15 @@ a space) at the start of each line:
>>>         possible for manual inspection; the exact format may change at
>>>         any time.
>>>
>>> +--color[=<when>]::
>>> +       Color file names. The value must be always (default), never,
>>> +       or auto.
>>
>> Here, the default is "always"...
>
> These (.txt changes in other patches as well) are mostly copy and
> paste from existing .txt files. You may want to grep through and fix
> other places as well, in a separate series.
>
>>
>>> +--no-color::
>>> +       Turn off coloring, even when the configuration file gives the
>>> +       default to color output, same as `--color=never`. This is the
>>> +       default.
>>
>> But, here the default is "never".
>
> What I mean is color is turned off by default for ls-files (in
> contrast, ls has color on by default). The default 'always' means that
> if you write --color without the <when> part, then it's
> --color=always. How do I phrase to make it clear?

Perhaps:

    Color file names. The value must be always, never, or auto.
    `--color` by itself is the same as `--color=always`.

> --
> Duy

Re: [PATCH v2 13/17] ls: add -1 short for --no-column in the spirit of GNU ls

[Eric Sunshine]

On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
> Subject: ls: add -1 short for --no-column in the spirit of GNU ls

The -1 option is POSIX [1]; not a GNU extension.

[1]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/ls.html

> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
> ---
>  Documentation/git-ls.txt | 3 +++
>  builtin/ls-files.c       | 2 ++
>  2 files changed, 5 insertions(+)
>
> diff --git a/Documentation/git-ls.txt b/Documentation/git-ls.txt
> index 10df6b0..0480c42 100644
> --- a/Documentation/git-ls.txt
> +++ b/Documentation/git-ls.txt
> @@ -51,6 +51,9 @@ OPTIONS
>  --recursive::
>         Equivalent of --max-depth=-1 (infinite recursion).
>
> +-1::
> +       Equivalent of --no-column.
> +
>  --color[=<when>]::
>         Color file names. The value must be always (default), never,
>         or auto.
> diff --git a/builtin/ls-files.c b/builtin/ls-files.c
> index 772a6ce..014de05 100644
> --- a/builtin/ls-files.c
> +++ b/builtin/ls-files.c
> @@ -729,6 +729,8 @@ int cmd_ls(int argc, const char **argv, const char *cmd_prefix)
>                             N_("shortcut for --max-depth=-1"), -1),
>                 OPT__COLOR(&use_color, N_("show color")),
>                 OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
> +               OPT_SET_INT('1', NULL, &colopts,
> +                           N_("shortcut for --no-column"), COL_PARSEOPT),
>                 { OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
>                         N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
>                         NULL, 1 },
> --
> 1.9.1.345.ga1a145c

Re: [PATCH v2 16/17] ls: do not show duplicate cached entries

[Eric Sunshine]

On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
> With the current show_files() "ls -tcm" will show
>
>   foo.c
> M foo.c
>
> The first item is redundant. If "foo.c" is modified, we know it's in
> the cache. Introduce show_files_compact to do that because ls-files is
> plumbing and scripts may already depend on current display behavior.
>
> Another difference in show_files_compact() is it does not show
> skip-worktree (aka outside sparse checkout) entries anymore, which
> makes sense in porcelain context.
>
> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
> ---
>  builtin/ls-files.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++++++-
>  1 file changed, 51 insertions(+), 1 deletion(-)
>
> diff --git a/builtin/ls-files.c b/builtin/ls-files.c
> index 709d8b1..cd8e35c 100644
> --- a/builtin/ls-files.c
> +++ b/builtin/ls-files.c
> @@ -337,6 +337,53 @@ static void show_files(struct dir_struct *dir)
>         }
>  }
>
> +static void show_files_compact(struct dir_struct *dir)
> +{
> +       int i;
> +
> +       /* For cached/deleted files we don't need to even do the readdir */
> +       if (show_others || show_killed) {
> +               if (!show_others)
> +                       dir->flags |= DIR_COLLECT_KILLED_ONLY;
> +               fill_directory(dir, &pathspec);
> +               if (show_others)
> +                       show_other_files(dir);
> +               if (show_killed)
> +                       show_killed_files(dir);
> +       }
> +       if (!(show_cached || show_stage || show_deleted || show_modified))
> +               return;
> +       for (i = 0; i < active_nr; i++) {
> +               const struct cache_entry *ce = active_cache[i];
> +               struct stat st;
> +               int err, shown = 0;
> +               if ((dir->flags & DIR_SHOW_IGNORED) &&
> +                   !ce_excluded(dir, ce))
> +                       continue;
> +               if (show_unmerged && !ce_stage(ce))
> +                       continue;
> +               if (ce->ce_flags & CE_UPDATE)
> +                       continue;
> +               if (ce_skip_worktree(ce))
> +                       continue;
> +               err = lstat(ce->name, &st);
> +               if (show_deleted && err) {
> +                       show_ce_entry(tag_removed, ce);
> +                       shown = 1;
> +               }
> +               if (show_modified && ce_modified(ce, &st, 0)) {

Is it possible for the lstat() to have failed for some reason when we
get here? If so, relying upon 'st' is unsafe, isn't it?

> +                       show_ce_entry(tag_modified, ce);
> +                       shown = 1;
> +               }
> +               if (ce_stage(ce)) {
> +                       show_ce_entry(tag_unmerged, ce);
> +                       shown = 1;
> +               }
> +               if (!shown && show_cached)
> +                       show_ce_entry(tag_cached, ce);
> +       }
> +}
> +
>  /*
>   * Prune the index to only contain stuff starting with "prefix"
>   */
> @@ -606,7 +653,10 @@ static int ls_files(const char **argv, const char *prefix)
>                 refresh_index(&the_index, REFRESH_QUIET, &pathspec, NULL, NULL);
>                 setup_pager();
>         }
> -       show_files(&dir);
> +       if (porcelain)
> +               show_files_compact(&dir);
> +       else
> +               show_files(&dir);
>         if (show_resolve_undo)
>                 show_ru_info();
>
> --
> 1.9.1.345.ga1a145c
>
> --
> To unsubscribe from this list: send the line "unsubscribe git" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH] ls-files: do not trust stat info if lstat() fails

[Nguyễn Thái Ngọc Duy]

If 'err' is non-zero, lstat() has failed. Consider the entry modified
without passing the (unreliable) stat info to ce_modified() in this
case.

Noticed-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 On Fri, Mar 28, 2014 at 11:04 AM, Eric Sunshine <sunshine@sunshineco.com> wrote:
 > On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
 >> +               err = lstat(ce->name, &st);
 >> +               if (show_deleted && err) {
 >> +                       show_ce_entry(tag_removed, ce);
 >> +                       shown = 1;
 >> +               }
 >> +               if (show_modified && ce_modified(ce, &st, 0)) {
 >
 > Is it possible for the lstat() to have failed for some reason when we
 > get here? If so, relying upon 'st' is unsafe, isn't it?

 The chance of random stat making ce_modified() return false is pretty
 low, but you're right. This code is a copy from the old show_files().
 I'll fix it in the git-ls series. Meanwhile a patch for maint to fix
 the original function.

 builtin/ls-files.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 47c3880..e6bd00e 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -260,7 +260,7 @@ static void show_files(struct dir_struct *dir)
 			err = lstat(ce->name, &st);
 			if (show_deleted && err)
 				show_ce_entry(tag_removed, ce);
-			if (show_modified && ce_modified(ce, &st, 0))
+			if (show_modified && (err || ce_modified(ce, &st, 0)))
 				show_ce_entry(tag_modified, ce);
 		}
 	}
-- 
1.9.1.345.ga1a145c

Re: [PATCH 7/8] ls-files: support --max-depth

[Matthieu Moy]

Duy Nguyen <pclouds@gmail.com> writes:

> I'd rather go with no trailing slash by default and add -F (which
> seems to be more than just '/')

... and then add a configuration variable to let users enable it by
default.

For GNU ls, I have "alias ls='ls -F --color=auto'" in my shell's
configuration, but I cannot push the analogy by aliasing "git ls"
because Git doesn't allow aliasing existing commands.

-- 
Matthieu Moy
http://www-verimag.imag.fr/~moy/

Re: [PATCH 7/8] ls-files: support --max-depth

[Duy Nguyen]

On Fri, Mar 28, 2014 at 8:52 PM, Matthieu Moy
<Matthieu.Moy@grenoble-inp.fr> wrote:
> Duy Nguyen <pclouds@gmail.com> writes:
>
>> I'd rather go with no trailing slash by default and add -F (which
>> seems to be more than just '/')
>
> ... and then add a configuration variable to let users enable it by
> default.
>
> For GNU ls, I have "alias ls='ls -F --color=auto'" in my shell's
> configuration, but I cannot push the analogy by aliasing "git ls"
> because Git doesn't allow aliasing existing commands.

I can do that but I want to push for a general solution instead
of ls-only. How about config key defaults.<cmd>, containing a list of
arguments, that will be prepended to git-<cmd>? Only some commands are
marked to support this by adding USE_DEFAULTS in the array commands[]
in git.c. And "git --no-defaults <cmd>" will ignore defaults.<cmd> (or
"git -c defaults.<cmd>= <cmd>" but it's less obvious). GIT_NO_DEFAULTS
can also be set, which has the same effect for all commands.
-- 
Duy

Re: [PATCH 7/8] ls-files: support --max-depth

[Duy Nguyen]

On Fri, Mar 28, 2014 at 9:15 PM, Duy Nguyen <pclouds@gmail.com> wrote:
> On Fri, Mar 28, 2014 at 8:52 PM, Matthieu Moy
> <Matthieu.Moy@grenoble-inp.fr> wrote:
>> Duy Nguyen <pclouds@gmail.com> writes:
>>
>>> I'd rather go with no trailing slash by default and add -F (which
>>> seems to be more than just '/')
>>
>> ... and then add a configuration variable to let users enable it by
>> default.
>>
>> For GNU ls, I have "alias ls='ls -F --color=auto'" in my shell's
>> configuration, but I cannot push the analogy by aliasing "git ls"
>> because Git doesn't allow aliasing existing commands.
>
> I can do that but I want to push for a general solution instead
> of ls-only. How about config key defaults.<cmd>, containing a list of
> arguments, that will be prepended to git-<cmd>? Only some commands are
> marked to support this by adding USE_DEFAULTS in the array commands[]
> in git.c. And "git --no-defaults <cmd>" will ignore defaults.<cmd> (or
> "git -c defaults.<cmd>= <cmd>" but it's less obvious). GIT_NO_DEFAULTS
> can also be set, which has the same effect for all commands.

Another option is to make git recognize program name g<something> and
auto map it to the alias <something>. For example, the symlink "gls"
will be executed as "git ls" (and the alias version is preferred over
the builtin one). Of course you can't have alias "it" because "git" is
already taken. It works for many cases, it's faster to type, and it
does not break current scripts.
-- 
Duy

[PATCH v3 00/18] git-ls

[Nguyễn Thái Ngọc Duy]

All comments by Eric are fixed in v3. -F is added. And the command
name is now list-files, not ls. 'ls' is saved for the user to make
an alias with better default options.

Nguyễn Thái Ngọc Duy (18):
  ls_colors.c: add $LS_COLORS parsing code
  ls_colors.c: parse color.ls.* from config file
  ls_colors.c: add a function to color a file name
  ls_colors.c: highlight submodules like directories
  ls-files: buffer full item in strbuf before printing
  ls-files: add --color to highlight file names
  ls-files: add --column
  ls-files: support --max-depth
  Add git-list-files, a user friendly version of ls-files and more
  list-files: -u does not imply showing stages
  list-files: add -R/--recursive short for --max-depth=-1
  list-files: add -1 short for --no-column
  list-files: add -t back
  list-files: sort output and remove duplicates
  list-files: do not show duplicate cached entries
  list-files: show directories as well as files
  list-files: add -F/--classify
  list-files -F: show submodules with the new indicator '&'

 .gitignore                             |   1 +
 Documentation/config.txt               |  22 ++
 Documentation/git-list-files.txt (new) |  99 +++++++
 Documentation/git-ls-files.txt         |  20 ++
 Makefile                               |   2 +
 builtin/ls-files.c                     | 358 ++++++++++++++++++++++--
 color.h                                |  10 +
 command-list.txt                       |   1 +
 git.c                                  |   1 +
 ls_colors.c (new)                      | 496 +++++++++++++++++++++++++++++++++
 10 files changed, 980 insertions(+), 30 deletions(-)
 create mode 100644 Documentation/git-list-files.txt
 create mode 100644 ls_colors.c

-- 
1.9.1.345.ga1a145c

[PATCH v3 01/18] ls_colors.c: add $LS_COLORS parsing code

[Nguyễn Thái Ngọc Duy]

Reusing color settings from $LS_COLORS could give a native look and
feel on file coloring.

This code is basically from coreutils.git [1], rewritten to fit Git.

As this is from GNU ls, the environment variable CLICOLOR is not
tested. It is to be decided later whether we should ignore $LS_COLORS
if $CLICOLOR is not set on Mac or FreeBSD.

[1] commit 7326d1f1a67edf21947ae98194f98c38b6e9e527 file
    src/ls.c. This is the last GPL-2 commit before coreutils turns to
    GPL-3.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Makefile          |   1 +
 color.h           |   8 ++
 ls_colors.c (new) | 398 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 407 insertions(+)
 create mode 100644 ls_colors.c

diff --git a/Makefile b/Makefile
index f818eec..f6a6e14 100644
--- a/Makefile
+++ b/Makefile
@@ -819,6 +819,7 @@ LIB_OBJS += list-objects.o
 LIB_OBJS += ll-merge.o
 LIB_OBJS += lockfile.o
 LIB_OBJS += log-tree.o
+LIB_OBJS += ls_colors.o
 LIB_OBJS += mailmap.o
 LIB_OBJS += match-trees.o
 LIB_OBJS += merge.o
diff --git a/color.h b/color.h
index 9a8495b..640fc48 100644
--- a/color.h
+++ b/color.h
@@ -45,6 +45,12 @@ struct strbuf;
 #define GIT_COLOR_BG_MAGENTA	"\033[45m"
 #define GIT_COLOR_BG_CYAN	"\033[46m"
 
+#define GIT_COLOR_WHITE_ON_RED    "\033[37;41m"
+#define GIT_COLOR_WHITE_ON_BLUE   "\033[37;44m"
+#define GIT_COLOR_BLACK_ON_YELLOW "\033[30;43m"
+#define GIT_COLOR_BLUE_ON_GREEN   "\033[34;42m"
+#define GIT_COLOR_BLACK_ON_GREEN  "\033[30;42m"
+
 /* A special value meaning "no color selected" */
 #define GIT_COLOR_NIL "NIL"
 
@@ -87,4 +93,6 @@ void color_print_strbuf(FILE *fp, const char *color, const struct strbuf *sb);
 
 int color_is_nil(const char *color);
 
+void parse_ls_color(void);
+
 #endif /* COLOR_H */
diff --git a/ls_colors.c b/ls_colors.c
new file mode 100644
index 0000000..eb944f4
--- /dev/null
+++ b/ls_colors.c
@@ -0,0 +1,398 @@
+#include "cache.h"
+#include "color.h"
+
+enum color_ls {
+	LS_LC,			/* left, unused */
+	LS_RC,			/* right, unused */
+	LS_EC,			/* end color, unused */
+	LS_RS,			/* reset */
+	LS_NO,			/* normal */
+	LS_FL,			/* file, default */
+	LS_DI,			/* directory */
+	LS_LN,			/* symlink */
+
+	LS_PI,			/* pipe */
+	LS_SO,			/* socket */
+	LS_BD,			/* block device */
+	LS_CD,			/* char device */
+	LS_MI,			/* missing file */
+	LS_OR,			/* orphaned symlink */
+	LS_EX,			/* executable */
+	LS_DO,			/* Solaris door */
+
+	LS_SU,			/* setuid */
+	LS_SG,			/* setgid */
+	LS_ST,			/* sticky */
+	LS_OW,			/* other-writable */
+	LS_TW,			/* ow with sticky */
+	LS_CA,			/* cap */
+	LS_MH,			/* multi hardlink */
+	LS_CL,			/* clear end of line */
+
+	MAX_LS
+};
+
+static char ls_colors[MAX_LS][COLOR_MAXLEN] = {
+	"",
+	"",
+	"",
+	GIT_COLOR_RESET,
+	GIT_COLOR_NORMAL,
+	GIT_COLOR_NORMAL,
+	GIT_COLOR_BOLD_BLUE,
+	GIT_COLOR_BOLD_CYAN,
+
+	GIT_COLOR_YELLOW,
+	GIT_COLOR_BOLD_MAGENTA,
+	GIT_COLOR_BOLD_YELLOW,
+	GIT_COLOR_BOLD_YELLOW,
+	GIT_COLOR_NORMAL,
+	GIT_COLOR_NORMAL,
+	GIT_COLOR_BOLD_GREEN,
+	GIT_COLOR_BOLD_MAGENTA,
+
+	GIT_COLOR_WHITE_ON_RED,
+	GIT_COLOR_BLACK_ON_YELLOW,
+	GIT_COLOR_WHITE_ON_BLUE,
+	GIT_COLOR_BLUE_ON_GREEN,
+	GIT_COLOR_BLACK_ON_GREEN,
+	"",
+	"",
+	""
+};
+
+static const char *const indicator_name[] = {
+	"lc", "rc", "ec", "rs", "no", "fi", "di", "ln",
+	"pi", "so", "bd", "cd", "mi", "or", "ex", "do",
+	"su", "sg", "st", "ow", "tw", "ca", "mh", "cl",
+	NULL
+};
+
+struct bin_str {
+	size_t len;			/* Number of bytes */
+	const char *string;		/* Pointer to the same */
+};
+
+struct color_ext_type {
+	struct bin_str ext;		/* The extension we're looking for */
+	struct bin_str seq;		/* The sequence to output when we do */
+	struct color_ext_type *next;	/* Next in list */
+};
+
+static struct color_ext_type *color_ext_list = NULL;
+
+/*
+ * When true, in a color listing, color each symlink name according to the
+ * type of file it points to.  Otherwise, color them according to the `ln'
+ * directive in LS_COLORS.  Dangling (orphan) symlinks are treated specially,
+ * regardless.  This is set when `ln=target' appears in LS_COLORS.
+ */
+static int color_symlink_as_referent;
+
+/*
+ * Parse a string as part of the LS_COLORS variable; this may involve
+ * decoding all kinds of escape characters.  If equals_end is set an
+ * unescaped equal sign ends the string, otherwise only a : or \0
+ * does.  Set *OUTPUT_COUNT to the number of bytes output.  Return
+ * true if successful.
+ *
+ * The resulting string is *not* null-terminated, but may contain
+ * embedded nulls.
+ *
+ * Note that both dest and src are char **; on return they point to
+ * the first free byte after the array and the character that ended
+ * the input string, respectively.
+ */
+static int get_funky_string(char **dest, const char **src, int equals_end,
+			    size_t *output_count)
+{
+	char num;			/* For numerical codes */
+	size_t count;			/* Something to count with */
+	enum {
+		ST_GND, ST_BACKSLASH, ST_OCTAL, ST_HEX,
+		ST_CARET, ST_END, ST_ERROR
+	} state;
+	const char *p;
+	char *q;
+
+	p = *src;			/* We don't want to double-indirect */
+	q = *dest;			/* the whole darn time.  */
+
+	count = 0;			/* No characters counted in yet.  */
+	num = 0;
+
+	state = ST_GND;		/* Start in ground state.  */
+	while (state < ST_END) {
+		switch (state) {
+		case ST_GND:		/* Ground state (no escapes) */
+			switch (*p) {
+			case ':':
+			case '\0':
+				state = ST_END;	/* End of string */
+				break;
+			case '\\':
+				state = ST_BACKSLASH; /* Backslash scape sequence */
+				++p;
+				break;
+			case '^':
+				state = ST_CARET; /* Caret escape */
+				++p;
+				break;
+			case '=':
+				if (equals_end) {
+					state = ST_END; /* End */
+					break;
+				}
+				/* else fall through */
+			default:
+				*(q++) = *(p++);
+				++count;
+				break;
+			}
+			break;
+
+		case ST_BACKSLASH:	/* Backslash escaped character */
+			switch (*p) {
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+				state = ST_OCTAL;	/* Octal sequence */
+				num = *p - '0';
+				break;
+			case 'x':
+			case 'X':
+				state = ST_HEX;	/* Hex sequence */
+				num = 0;
+				break;
+			case 'a':		/* Bell */
+				num = '\a';
+				break;
+			case 'b':		/* Backspace */
+				num = '\b';
+				break;
+			case 'e':		/* Escape */
+				num = 27;
+				break;
+			case 'f':		/* Form feed */
+				num = '\f';
+				break;
+			case 'n':		/* Newline */
+				num = '\n';
+				break;
+			case 'r':		/* Carriage return */
+				num = '\r';
+				break;
+			case 't':		/* Tab */
+				num = '\t';
+				break;
+			case 'v':		/* Vtab */
+				num = '\v';
+				break;
+			case '?':		/* Delete */
+				num = 127;
+				break;
+			case '_':		/* Space */
+				num = ' ';
+				break;
+			case '\0':		/* End of string */
+				state = ST_ERROR;	/* Error! */
+				break;
+			default:		/* Escaped character like \ ^ : = */
+				num = *p;
+				break;
+			}
+			if (state == ST_BACKSLASH) {
+				*(q++) = num;
+				++count;
+				state = ST_GND;
+			}
+			++p;
+			break;
+
+		case ST_OCTAL:		/* Octal sequence */
+			if (*p < '0' || *p > '7') {
+				*(q++) = num;
+				++count;
+				state = ST_GND;
+			} else
+				num = (num << 3) + (*(p++) - '0');
+			break;
+
+		case ST_HEX:		/* Hex sequence */
+			switch (*p) {
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+			case '8':
+			case '9':
+				num = (num << 4) + (*(p++) - '0');
+				break;
+			case 'a':
+			case 'b':
+			case 'c':
+			case 'd':
+			case 'e':
+			case 'f':
+				num = (num << 4) + (*(p++) - 'a') + 10;
+				break;
+			case 'A':
+			case 'B':
+			case 'C':
+			case 'D':
+			case 'E':
+			case 'F':
+				num = (num << 4) + (*(p++) - 'A') + 10;
+				break;
+			default:
+				*(q++) = num;
+				++count;
+				state = ST_GND;
+				break;
+			}
+			break;
+
+		case ST_CARET:		/* Caret escape */
+			state = ST_GND;	/* Should be the next state... */
+			if (*p >= '@' && *p <= '~') {
+				*(q++) = *(p++) & 037;
+				++count;
+			} else if (*p == '?') {
+				*(q++) = 127;
+				++count;
+			} else
+				state = ST_ERROR;
+			break;
+
+		default:
+			abort();
+		}
+	}
+
+	*dest = q;
+	*src = p;
+	*output_count = count;
+
+	return state != ST_ERROR;
+}
+
+void parse_ls_color(void)
+{
+	const char *p;			/* Pointer to character being parsed */
+	char *buf;			/* color_buf buffer pointer */
+	int state;			/* State of parser */
+	int ind_no;			/* Indicator number */
+	char label[3];			/* Indicator label */
+	struct color_ext_type *ext;	/* Extension we are working on */
+	static char *color_buf;
+	char *start;
+	size_t len;
+
+	if ((p = getenv("LS_COLORS")) == NULL || *p == '\0')
+		return;
+
+	ext = NULL;
+	strcpy (label, "??");
+
+	/*
+	 * This is an overly conservative estimate, but any possible
+	 * LS_COLORS string will *not* generate a color_buf longer
+	 * than itself, so it is a safe way of allocating a buffer in
+	 * advance.
+	 */
+	buf = color_buf = xstrdup(p);
+
+	state = 1;
+	while (state > 0) {
+		switch (state) {
+		case 1:		/* First label character */
+			switch (*p) {
+			case ':':
+				++p;
+				break;
+
+			case '*':
+				/*
+				 * Allocate new extension block and add to head of
+				 * linked list (this way a later definition will
+				 * override an earlier one, which can be useful for
+				 * having terminal-specific defs override global).
+				 */
+
+				ext = xmalloc(sizeof *ext);
+				ext->next = color_ext_list;
+				color_ext_list = ext;
+
+				++p;
+				ext->ext.string = buf;
+
+				state = (get_funky_string(&buf, &p, 1, &ext->ext.len)
+					 ? 4 : -1);
+				break;
+
+			case '\0':
+				state = 0;	/* Done! */
+				break;
+
+			default:	/* Assume it is file type label */
+				label[0] = *(p++);
+				state = 2;
+				break;
+			}
+			break;
+
+		case 2:		/* Second label character */
+			if (*p) {
+				label[1] = *(p++);
+				state = 3;
+			} else
+				state = -1;	/* Error */
+			break;
+
+		case 3:		/* Equal sign after indicator label */
+			state = -1;	/* Assume failure...  */
+			if (*(p++) != '=')
+				break;
+			for (ind_no = 0; indicator_name[ind_no] != NULL; ++ind_no) {
+				if (!strcmp(label, indicator_name[ind_no])) {
+					start = buf;
+					if (get_funky_string(&buf, &p, 0, &len))
+						state = 1;
+					else
+						state = -1;
+					break;
+				}
+			}
+			if (state == -1)
+				error(_("unrecognized prefix: %s"), label);
+			else if (ind_no == LS_LN && len == 6 &&
+				 starts_with(start, "target"))
+				color_symlink_as_referent = 1;
+			else
+				sprintf(ls_colors[ind_no], "\033[%.*sm",
+				       (int)len, start);
+			break;
+
+		case 4:		/* Equal sign after *.ext */
+			if (*(p++) == '=') {
+				ext->seq.string = buf;
+				state = (get_funky_string(&buf, &p, 0, &ext->seq.len)
+					 ? 1 : -1);
+			} else
+				state = -1;
+			break;
+		}
+	}
+
+	if (!strcmp(ls_colors[LS_LN], "target"))
+		color_symlink_as_referent = 1;
+}
-- 
1.9.1.345.ga1a145c

[PATCH v3 02/18] ls_colors.c: parse color.ls.* from config file

[Nguyễn Thái Ngọc Duy]

This is the second (and preferred) source for color information. This
will override $LS_COLORS.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/config.txt | 11 +++++++++++
 ls_colors.c              | 26 ++++++++++++++++++++++++++
 2 files changed, 37 insertions(+)

diff --git a/Documentation/config.txt b/Documentation/config.txt
index 73c8973..3fb754e 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -909,6 +909,17 @@ color.status.<slot>::
 	to red). The values of these variables may be specified as in
 	color.branch.<slot>.
 
+color.ls.<slot>::
+	Use customized color for file name colorization. If not set
+	and the environment variable LS_COLORS is set, color settings
+	from $LS_COLORS are used. `<slot>` can be `normal`, `file`,
+	`directory`, `symlink`, `fifo`, `socket`, `block`, `char`,
+	`missing`, `orphan`, `executable`, `door`, `setuid`, `setgid`,
+	`sticky`, `otherwritable`, `stickyotherwritable`, `cap`,
+	`multihardlink`. The values of these variables may be
+	specified as in color.branch.<slot>.
+
+
 color.ui::
 	This variable determines the default value for variables such
 	as `color.diff` and `color.grep` that control the use of color
diff --git a/ls_colors.c b/ls_colors.c
index eb944f4..cef5a92 100644
--- a/ls_colors.c
+++ b/ls_colors.c
@@ -68,6 +68,14 @@ static const char *const indicator_name[] = {
 	NULL
 };
 
+static const char* const config_name[] = {
+	"", "", "", "", "normal", "file", "directory", "symlink",
+	"fifo", "socket", "block", "char", "missing", "orphan", "executable",
+	"door", "setuid", "setgid", "sticky", "otherwritable",
+	"stickyotherwritable", "cap", "multihardlink", "",
+	NULL
+};
+
 struct bin_str {
 	size_t len;			/* Number of bytes */
 	const char *string;		/* Pointer to the same */
@@ -285,6 +293,23 @@ static int get_funky_string(char **dest, const char **src, int equals_end,
 	return state != ST_ERROR;
 }
 
+static int ls_colors_config(const char *var, const char *value, void *cb)
+{
+	int slot;
+	if (!starts_with(var, "color.ls."))
+		return 0;
+	var += 9;
+	for (slot = 0; config_name[slot]; slot++)
+		if (!strcasecmp(var, config_name[slot]))
+			break;
+	if (!config_name[slot])
+		return 0;
+	if (!value)
+		return config_error_nonbool(var);
+	color_parse(value, var, ls_colors[slot]);
+	return 0;
+}
+
 void parse_ls_color(void)
 {
 	const char *p;			/* Pointer to character being parsed */
@@ -395,4 +420,5 @@ void parse_ls_color(void)
 
 	if (!strcmp(ls_colors[LS_LN], "target"))
 		color_symlink_as_referent = 1;
+	git_config(ls_colors_config, NULL);
 }
-- 
1.9.1.345.ga1a145c

[PATCH v3 03/18] ls_colors.c: add a function to color a file name

[Nguyễn Thái Ngọc Duy]

The new function is based on print_color_indicator() from commit
7326d1f1a67edf21947ae98194f98c38b6e9e527 in coreutils.git.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 color.h     |  2 ++
 ls_colors.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+)

diff --git a/color.h b/color.h
index 640fc48..398369a 100644
--- a/color.h
+++ b/color.h
@@ -94,5 +94,7 @@ void color_print_strbuf(FILE *fp, const char *color, const struct strbuf *sb);
 int color_is_nil(const char *color);
 
 void parse_ls_color(void);
+void color_filename(struct strbuf *sb, const char *name,
+		    const char *display_name, mode_t mode, int linkok);
 
 #endif /* COLOR_H */
diff --git a/ls_colors.c b/ls_colors.c
index cef5a92..1125329 100644
--- a/ls_colors.c
+++ b/ls_colors.c
@@ -422,3 +422,69 @@ void parse_ls_color(void)
 		color_symlink_as_referent = 1;
 	git_config(ls_colors_config, NULL);
 }
+
+void color_filename(struct strbuf *sb, const char *name,
+		    const char *display_name, mode_t mode, int linkok)
+{
+	int type;
+	struct color_ext_type *ext;	/* Color extension */
+
+	if (S_ISREG (mode)) {
+		type = LS_FL;
+		if ((mode & S_ISUID) != 0)
+			type = LS_SU;
+		else if ((mode & S_ISGID) != 0)
+			type = LS_SG;
+		else if ((mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0)
+			type = LS_EX;
+	} else if (S_ISDIR (mode)) {
+		if ((mode & S_ISVTX) && (mode & S_IWOTH))
+			type = LS_TW;
+		else if ((mode & S_IWOTH) != 0)
+			type = LS_OW;
+		else if ((mode & S_ISVTX) != 0)
+			type = LS_ST;
+		else
+			type = LS_DI;
+	} else if (S_ISLNK (mode))
+		type = (!linkok && *ls_colors[LS_OR]) ? LS_OR : LS_LN;
+	else if (S_ISFIFO (mode))
+		type = LS_PI;
+	else if (S_ISSOCK (mode))
+		type = LS_SO;
+	else if (S_ISBLK (mode))
+		type = LS_BD;
+	else if (S_ISCHR (mode))
+		type = LS_CD;
+#ifdef S_ISDOOR
+	else if (S_ISDOOR (mode))
+		type = LS_DO;
+#endif
+	else
+		/* Classify a file of some other type as C_ORPHAN.  */
+		type = LS_OR;
+
+	/* Check the file's suffix only if still classified as C_FILE.  */
+	ext = NULL;
+	if (type == LS_FL) {
+		/* Test if NAME has a recognized suffix.  */
+		size_t len = strlen(name);
+		const char *p = name + len;		/* Pointer to final \0.  */
+		for (ext = color_ext_list; ext != NULL; ext = ext->next) {
+			if (ext->ext.len <= len &&
+			    !strncmp(p - ext->ext.len, ext->ext.string, ext->ext.len))
+				break;
+		}
+	}
+
+	if (display_name)
+		name = display_name;
+	if (ext)
+		strbuf_addf(sb, "\033[%.*sm%s%s",
+			    (int)ext->seq.len, ext->seq.string,
+			    name, GIT_COLOR_RESET);
+	else if (*ls_colors[type])
+		strbuf_addf(sb, "%s%s%s", ls_colors[type], name, GIT_COLOR_RESET);
+	else
+		strbuf_addstr(sb, name);
+}
-- 
1.9.1.345.ga1a145c

[PATCH v3 04/18] ls_colors.c: highlight submodules like directories

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/config.txt | 3 ++-
 ls_colors.c              | 8 +++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/Documentation/config.txt b/Documentation/config.txt
index 3fb754e..6bca55e 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -913,7 +913,8 @@ color.ls.<slot>::
 	Use customized color for file name colorization. If not set
 	and the environment variable LS_COLORS is set, color settings
 	from $LS_COLORS are used. `<slot>` can be `normal`, `file`,
-	`directory`, `symlink`, `fifo`, `socket`, `block`, `char`,
+	`directory`, `submodule`,
+	`symlink`, `fifo`, `socket`, `block`, `char`,
 	`missing`, `orphan`, `executable`, `door`, `setuid`, `setgid`,
 	`sticky`, `otherwritable`, `stickyotherwritable`, `cap`,
 	`multihardlink`. The values of these variables may be
diff --git a/ls_colors.c b/ls_colors.c
index 1125329..0cc4e9b 100644
--- a/ls_colors.c
+++ b/ls_colors.c
@@ -29,6 +29,8 @@ enum color_ls {
 	LS_MH,			/* multi hardlink */
 	LS_CL,			/* clear end of line */
 
+	LS_SUBMODULE,
+
 	MAX_LS
 };
 
@@ -58,7 +60,8 @@ static char ls_colors[MAX_LS][COLOR_MAXLEN] = {
 	GIT_COLOR_BLACK_ON_GREEN,
 	"",
 	"",
-	""
+	"",
+	GIT_COLOR_BOLD_BLUE
 };
 
 static const char *const indicator_name[] = {
@@ -73,6 +76,7 @@ static const char* const config_name[] = {
 	"fifo", "socket", "block", "char", "missing", "orphan", "executable",
 	"door", "setuid", "setgid", "sticky", "otherwritable",
 	"stickyotherwritable", "cap", "multihardlink", "",
+	"submodule",
 	NULL
 };
 
@@ -448,6 +452,8 @@ void color_filename(struct strbuf *sb, const char *name,
 			type = LS_DI;
 	} else if (S_ISLNK (mode))
 		type = (!linkok && *ls_colors[LS_OR]) ? LS_OR : LS_LN;
+	else if (S_ISGITLINK(mode))
+		type = LS_SUBMODULE;
 	else if (S_ISFIFO (mode))
 		type = LS_PI;
 	else if (S_ISSOCK (mode))
-- 
1.9.1.345.ga1a145c

[PATCH v3 05/18] ls-files: buffer full item in strbuf before printing

[Nguyễn Thái Ngọc Duy]

Buffering so that we can manipulate the strings (e.g. coloring)
further before finally printing them.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 48 +++++++++++++++++++++++++++++++++++-------------
 1 file changed, 35 insertions(+), 13 deletions(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 47c3880..6e30592 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -47,18 +47,30 @@ static const char *tag_modified = "";
 static const char *tag_skip_worktree = "";
 static const char *tag_resolve_undo = "";
 
-static void write_name(const char *name)
+static void write_name(struct strbuf *sb, const char *name)
 {
 	/*
 	 * With "--full-name", prefix_len=0; this caller needs to pass
 	 * an empty string in that case (a NULL is good for "").
 	 */
-	write_name_quoted_relative(name, prefix_len ? prefix : NULL,
-				   stdout, line_terminator);
+	const char *real_prefix = prefix_len ? prefix : NULL;
+	if (!line_terminator) {
+		struct strbuf sb2 = STRBUF_INIT;
+		strbuf_addstr(sb, relative_path(name, real_prefix, &sb2));
+		strbuf_release(&sb2);
+	} else
+		quote_path_relative(name, real_prefix, sb);
+	strbuf_addch(sb, line_terminator);
+}
+
+static void strbuf_fputs(struct strbuf *sb, FILE *fp)
+{
+	fwrite(sb->buf, sb->len, 1, fp);
 }
 
 static void show_dir_entry(const char *tag, struct dir_entry *ent)
 {
+	static struct strbuf sb = STRBUF_INIT;
 	int len = max_prefix_len;
 
 	if (len >= ent->len)
@@ -67,8 +79,10 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
 	if (!dir_path_match(ent, &pathspec, len, ps_matched))
 		return;
 
-	fputs(tag, stdout);
-	write_name(ent->name);
+	strbuf_reset(&sb);
+	strbuf_addstr(&sb, tag);
+	write_name(&sb, ent->name);
+	strbuf_fputs(&sb, stdout);
 }
 
 static void show_other_files(struct dir_struct *dir)
@@ -134,6 +148,7 @@ static void show_killed_files(struct dir_struct *dir)
 
 static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 {
+	static struct strbuf sb = STRBUF_INIT;
 	int len = max_prefix_len;
 
 	if (len >= ce_namelen(ce))
@@ -161,16 +176,18 @@ static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 		tag = alttag;
 	}
 
+	strbuf_reset(&sb);
 	if (!show_stage) {
-		fputs(tag, stdout);
+		strbuf_addstr(&sb, tag);
 	} else {
-		printf("%s%06o %s %d\t",
-		       tag,
-		       ce->ce_mode,
-		       find_unique_abbrev(ce->sha1,abbrev),
-		       ce_stage(ce));
+		strbuf_addf(&sb, "%s%06o %s %d\t",
+			    tag,
+			    ce->ce_mode,
+			    find_unique_abbrev(ce->sha1,abbrev),
+			    ce_stage(ce));
 	}
-	write_name(ce->name);
+	write_name(&sb, ce->name);
+	strbuf_fputs(&sb, stdout);
 	if (debug_mode) {
 		const struct stat_data *sd = &ce->ce_stat_data;
 
@@ -206,7 +223,12 @@ static void show_ru_info(void)
 			printf("%s%06o %s %d\t", tag_resolve_undo, ui->mode[i],
 			       find_unique_abbrev(ui->sha1[i], abbrev),
 			       i + 1);
-			write_name(path);
+			/*
+			 * With "--full-name", prefix_len=0; this caller needs to pass
+			 * an empty string in that case (a NULL is good for "").
+			 */
+			write_name_quoted_relative(path, prefix_len ? prefix : NULL,
+						   stdout, line_terminator);
 		}
 	}
 }
-- 
1.9.1.345.ga1a145c

[PATCH v3 06/18] ls-files: add --color to highlight file names

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-ls-files.txt |  7 +++++++
 builtin/ls-files.c             | 38 +++++++++++++++++++++++++++++++++++---
 2 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
index c0856a6..f006fc1 100644
--- a/Documentation/git-ls-files.txt
+++ b/Documentation/git-ls-files.txt
@@ -147,6 +147,13 @@ a space) at the start of each line:
 	possible for manual inspection; the exact format may change at
 	any time.
 
+--color[=<when>]::
+--no-color::
+	Color file names. The value must be `always`, `never`, or
+	`auto`. `--no-color` is equivalent to
+	`--color=never`. `--color` is equivalent to
+	`--color=auto`.
+
 \--::
 	Do not interpret any more arguments as options.
 
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 6e30592..2857b38 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -14,6 +14,7 @@
 #include "resolve-undo.h"
 #include "string-list.h"
 #include "pathspec.h"
+#include "color.h"
 
 static int abbrev;
 static int show_deleted;
@@ -27,6 +28,7 @@ static int show_killed;
 static int show_valid_bit;
 static int line_terminator = '\n';
 static int debug_mode;
+static int use_color;
 
 static const char *prefix;
 static int max_prefix_len;
@@ -60,7 +62,6 @@ static void write_name(struct strbuf *sb, const char *name)
 		strbuf_release(&sb2);
 	} else
 		quote_path_relative(name, real_prefix, sb);
-	strbuf_addch(sb, line_terminator);
 }
 
 static void strbuf_fputs(struct strbuf *sb, FILE *fp)
@@ -68,6 +69,21 @@ static void strbuf_fputs(struct strbuf *sb, FILE *fp)
 	fwrite(sb->buf, sb->len, 1, fp);
 }
 
+static void write_dir_entry(struct strbuf *sb, const struct dir_entry *ent)
+{
+	struct strbuf quoted = STRBUF_INIT;
+	struct stat st;
+	if (stat(ent->name, &st))
+		st.st_mode = 0;
+	write_name(&quoted, ent->name);
+	if (want_color(use_color))
+		color_filename(sb, ent->name, quoted.buf, st.st_mode, 1);
+	else
+		strbuf_addbuf(sb, &quoted);
+	strbuf_addch(sb, line_terminator);
+	strbuf_release(&quoted);
+}
+
 static void show_dir_entry(const char *tag, struct dir_entry *ent)
 {
 	static struct strbuf sb = STRBUF_INIT;
@@ -81,7 +97,7 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
 
 	strbuf_reset(&sb);
 	strbuf_addstr(&sb, tag);
-	write_name(&sb, ent->name);
+	write_dir_entry(&sb, ent);
 	strbuf_fputs(&sb, stdout);
 }
 
@@ -146,6 +162,18 @@ static void show_killed_files(struct dir_struct *dir)
 	}
 }
 
+static void write_ce_name(struct strbuf *sb, const struct cache_entry *ce)
+{
+	struct strbuf quoted = STRBUF_INIT;
+	write_name(&quoted, ce->name);
+	if (want_color(use_color))
+		color_filename(sb, ce->name, quoted.buf, ce->ce_mode, 1);
+	else
+		strbuf_addbuf(sb, &quoted);
+	strbuf_addch(sb, line_terminator);
+	strbuf_release(&quoted);
+}
+
 static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 {
 	static struct strbuf sb = STRBUF_INIT;
@@ -186,7 +214,7 @@ static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 			    find_unique_abbrev(ce->sha1,abbrev),
 			    ce_stage(ce));
 	}
-	write_name(&sb, ce->name);
+	write_ce_name(&sb, ce);
 	strbuf_fputs(&sb, stdout);
 	if (debug_mode) {
 		const struct stat_data *sd = &ce->ce_stat_data;
@@ -523,6 +551,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			N_("if any <file> is not in the index, treat this as an error")),
 		OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
 			N_("pretend that paths removed since <tree-ish> are still present")),
+		OPT__COLOR(&use_color, N_("show color")),
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -570,6 +599,9 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	if (require_work_tree && !is_inside_work_tree())
 		setup_work_tree();
 
+	if (want_color(use_color))
+		parse_ls_color();
+
 	parse_pathspec(&pathspec, 0,
 		       PATHSPEC_PREFER_CWD |
 		       PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
-- 
1.9.1.345.ga1a145c

[PATCH v3 07/18] ls-files: add --column

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-ls-files.txt |  6 ++++++
 builtin/ls-files.c             | 28 ++++++++++++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
index f006fc1..a5a30c2 100644
--- a/Documentation/git-ls-files.txt
+++ b/Documentation/git-ls-files.txt
@@ -154,6 +154,12 @@ a space) at the start of each line:
 	`--color=never`. `--color` is equivalent to
 	`--color=auto`.
 
+--column[=<options>]::
+--no-column::
+	Display files in columns. See configuration variable column.ui
+	for option syntax. `--column` and `--no-column` without options
+	are equivalent to 'always' and 'never' respectively.
+
 \--::
 	Do not interpret any more arguments as options.
 
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 2857b38..a481c37 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -15,6 +15,7 @@
 #include "string-list.h"
 #include "pathspec.h"
 #include "color.h"
+#include "column.h"
 
 static int abbrev;
 static int show_deleted;
@@ -29,6 +30,7 @@ static int show_valid_bit;
 static int line_terminator = '\n';
 static int debug_mode;
 static int use_color;
+static unsigned int colopts;
 
 static const char *prefix;
 static int max_prefix_len;
@@ -39,6 +41,7 @@ static char *ps_matched;
 static const char *with_tree;
 static int exc_given;
 static int exclude_args;
+static struct string_list output = STRING_LIST_INIT_NODUP;
 
 static const char *tag_cached = "";
 static const char *tag_unmerged = "";
@@ -66,6 +69,10 @@ static void write_name(struct strbuf *sb, const char *name)
 
 static void strbuf_fputs(struct strbuf *sb, FILE *fp)
 {
+	if (column_active(colopts)) {
+		string_list_append(&output, strbuf_detach(sb, NULL));
+		return;
+	}
 	fwrite(sb->buf, sb->len, 1, fp);
 }
 
@@ -552,6 +559,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		OPT_STRING(0, "with-tree", &with_tree, N_("tree-ish"),
 			N_("pretend that paths removed since <tree-ish> are still present")),
 		OPT__COLOR(&use_color, N_("show color")),
+		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -596,6 +604,18 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	if (dir.exclude_per_dir)
 		exc_given = 1;
 
+	finalize_colopts(&colopts, -1);
+	if (explicitly_enable_column(colopts)) {
+		if (!line_terminator)
+			die(_("--column and -z are incompatible"));
+		if (show_resolve_undo)
+			die(_("--column and --resolve-undo are incompatible"));
+		if (debug_mode)
+			die(_("--column and --debug are incompatible"));
+	}
+	if (column_active(colopts))
+		line_terminator = 0;
+
 	if (require_work_tree && !is_inside_work_tree())
 		setup_work_tree();
 
@@ -638,6 +658,14 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	if (show_resolve_undo)
 		show_ru_info();
 
+	if (column_active(colopts)) {
+		struct column_options copts;
+		memset(&copts, 0, sizeof(copts));
+		copts.padding = 2;
+		print_columns(&output, colopts, &copts);
+		string_list_clear(&output, 0);
+	}
+
 	if (ps_matched) {
 		int bad;
 		bad = report_path_error(ps_matched, &pathspec, prefix);
-- 
1.9.1.345.ga1a145c

[PATCH v3 08/18] ls-files: support --max-depth

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-ls-files.txt | 7 +++++++
 builtin/ls-files.c             | 7 +++++++
 2 files changed, 14 insertions(+)

diff --git a/Documentation/git-ls-files.txt b/Documentation/git-ls-files.txt
index a5a30c2..ad621b5 100644
--- a/Documentation/git-ls-files.txt
+++ b/Documentation/git-ls-files.txt
@@ -160,6 +160,13 @@ a space) at the start of each line:
 	for option syntax. `--column` and `--no-column` without options
 	are equivalent to 'always' and 'never' respectively.
 
+--max-depth=<depth>::
+	For each <pathspec> given on command line, descend at most <depth>
+	levels of directories. A negative value means no limit (default).
+	This option is ignored if <pathspec> contains active wildcards.
+	In other words if "a*" matches a directory named "a*",
+	"*" is matched literally so --max-depth is still effective.
+
 \--::
 	Do not interpret any more arguments as options.
 
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index a481c37..130bed0 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -503,6 +503,7 @@ static int option_parse_exclude_standard(const struct option *opt,
 int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 {
 	int require_work_tree = 0, show_tag = 0, i;
+	int max_depth = -1;
 	const char *max_prefix;
 	struct dir_struct dir;
 	struct exclude_list *el;
@@ -560,6 +561,9 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			N_("pretend that paths removed since <tree-ish> are still present")),
 		OPT__COLOR(&use_color, N_("show color")),
 		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
+		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
+			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
+			NULL, 1 },
 		OPT__ABBREV(&abbrev),
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
@@ -624,8 +628,11 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 
 	parse_pathspec(&pathspec, 0,
 		       PATHSPEC_PREFER_CWD |
+		       (max_depth != -1 ? PATHSPEC_MAXDEPTH_VALID : 0) |
 		       PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
 		       prefix, argv);
+	pathspec.max_depth = max_depth;
+	pathspec.recursive = 1;
 
 	/* Find common prefix for all pathspec's */
 	max_prefix = common_prefix(&pathspec);
-- 
1.9.1.345.ga1a145c

[PATCH v3 09/18] Add git-list-files, a user friendly version of ls-files and more

[Nguyễn Thái Ngọc Duy]

This is more user friendly version of ls-files:

* it's automatically colored and columnized
* it refreshes the index like all porcelain commands
* it defaults to non-recursive behavior like ls
* :(glob) is on by default so '*.c' means a.c but not a/b.c, use
  '**/*.c' for that.
* auto pager

The name 'ls' is not taken. It is left for the user to make an alias
with better default options.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 .gitignore                             |  1 +
 Documentation/config.txt               | 10 +++++
 Documentation/git-list-files.txt (new) | 80 ++++++++++++++++++++++++++++++++++
 Makefile                               |  1 +
 builtin/ls-files.c                     | 69 +++++++++++++++++++++++++++--
 command-list.txt                       |  1 +
 git.c                                  |  1 +
 7 files changed, 159 insertions(+), 4 deletions(-)
 create mode 100644 Documentation/git-list-files.txt

diff --git a/.gitignore b/.gitignore
index dc600f9..faeac5d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -75,6 +75,7 @@
 /git-init
 /git-init-db
 /git-instaweb
+/git-list-files
 /git-log
 /git-ls-files
 /git-ls-remote
diff --git a/Documentation/config.txt b/Documentation/config.txt
index 6bca55e..e07e8bc 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt
@@ -909,6 +909,12 @@ color.status.<slot>::
 	to red). The values of these variables may be specified as in
 	color.branch.<slot>.
 
+color.list-files::
+	A boolean to enable/disable color in the output of
+	linkgit:git-list-files[1]. May be set to `always`, `false` (or
+	`never`) or `auto` (or `true`), in which case colors are used
+	only when the output is to a terminal. Defaults to false.
+
 color.ls.<slot>::
 	Use customized color for file name colorization. If not set
 	and the environment variable LS_COLORS is set, color settings
@@ -981,6 +987,10 @@ column.clean::
 	Specify the layout when list items in `git clean -i`, which always
 	shows files and directories in columns. See `column.ui` for details.
 
+column.list-files::
+	Specify whether to output tag listing in `git list-files` in columns.
+	See `column.ui` for details.
+
 column.status::
 	Specify whether to output untracked files in `git status` in columns.
 	See `column.ui` for details.
diff --git a/Documentation/git-list-files.txt b/Documentation/git-list-files.txt
new file mode 100644
index 0000000..3039e1e
--- /dev/null
+++ b/Documentation/git-list-files.txt
@@ -0,0 +1,80 @@
+git-list-files(1)
+===============
+
+NAME
+----
+git-list-files - List files
+
+SYNOPSIS
+--------
+[verse]
+'git list-files [options] [<pathspec>...]
+
+DESCRIPTION
+-----------
+List files (by default in current working directory) that are in the
+index. Depending on the chosen options, maybe only modified files in
+working tree are shown, or untracked files...
+
+OPTIONS
+-------
+-c::
+--cached::
+	Show cached files (default)
+
+-d::
+--deleted::
+	Show cached files that are deleted on working directory
+
+-m::
+--modified::
+	Show cached files that have modification on working directory
+
+-o::
+--others::
+	Show untracked files (and only unignored ones unless -i is
+	specified)
+
+-i::
+--ignored::
+	Show only ignored files. When showing files in the index,
+	print only those matched by an exclude pattern. When showing
+	"other" files, show only those matched by an exclude pattern.
+
+-u::
+--unmerged::
+	Show unmerged files
+
+--color[=<when>]::
+--no-color::
+	Color file names. The value must be `always`, `never`, or
+	`auto`. `--no-color` is equivalent to
+	`--color=never`. `--color` is equivalent to
+	`--color=auto`. See configuration variable `color.list-files`
+	for the default settings.
+
+--column[=<options>]::
+--no-column::
+	Display files in columns. See configuration variable column.ui
+	for option syntax. `--column` and `--no-column` without options
+	are equivalent to 'always' and 'never' respectively.
+
+--max-depth=<depth>::
+	For each <pathspec> given on command line, descend at most <depth>
+	levels of directories. A negative value means no limit.
+	This option is ignored if <pathspec> contains active wildcards.
+	In other words if "a*" matches a directory named "a*",
+	"*" is matched literally so --max-depth is still effective.
+	The default is `--max-depth=0`.
+
+<pathspec>::
+	Files to show. :(glob) magic is enabled and recursion disabled
+	by default.
+
+SEE ALSO
+--------
+linkgit:git-ls-files[1]
+
+GIT
+---
+Part of the linkgit:git[1] suite
diff --git a/Makefile b/Makefile
index f6a6e14..6104e05 100644
--- a/Makefile
+++ b/Makefile
@@ -584,6 +584,7 @@ BUILT_INS += git-cherry-pick$X
 BUILT_INS += git-format-patch$X
 BUILT_INS += git-fsck-objects$X
 BUILT_INS += git-init$X
+BUILT_INS += git-list-files$X
 BUILT_INS += git-merge-subtree$X
 BUILT_INS += git-show$X
 BUILT_INS += git-stage$X
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 130bed0..0ae07b0 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -31,6 +31,7 @@ static int line_terminator = '\n';
 static int debug_mode;
 static int use_color;
 static unsigned int colopts;
+static int porcelain;
 
 static const char *prefix;
 static int max_prefix_len;
@@ -459,6 +460,11 @@ static const char * const ls_files_usage[] = {
 	NULL
 };
 
+static const char * const ls_usage[] = {
+	N_("git list-files [options] [<file>...]"),
+	NULL
+};
+
 static int option_parse_z(const struct option *opt,
 			  const char *arg, int unset)
 {
@@ -500,6 +506,17 @@ static int option_parse_exclude_standard(const struct option *opt,
 	return 0;
 }
 
+static int git_ls_config(const char *var, const char *value, void *cb)
+{
+	if (starts_with(var, "column."))
+		return git_column_config(var, value, "list-files", &colopts);
+	if (!strcmp(var, "color.list-files")) {
+		use_color = git_config_colorbool(var, value);
+		return 0;
+	}
+	return git_color_default_config(var, value, cb);
+}
+
 int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 {
 	int require_work_tree = 0, show_tag = 0, i;
@@ -568,21 +585,61 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		OPT_BOOL(0, "debug", &debug_mode, N_("show debugging data")),
 		OPT_END()
 	};
+	struct option builtin_ls_options[] = {
+		OPT_BOOL('c', "cached", &show_cached,
+			N_("show cached files (default)")),
+		OPT_BOOL('d', "deleted", &show_deleted,
+			N_("show cached files that are deleted on working directory")),
+		OPT_BOOL('m', "modified", &show_modified,
+			N_("show cached files that have modification on working directory")),
+		OPT_BOOL('o', "others", &show_others,
+			N_("show untracked files")),
+		OPT_BIT('i', "ignored", &dir.flags,
+			N_("show ignored files"),
+			DIR_SHOW_IGNORED),
+		OPT_BOOL('u', "unmerged", &show_unmerged,
+			N_("show unmerged files")),
+		OPT__COLOR(&use_color, N_("show color")),
+		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
+		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
+			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
+			NULL, 1 },
+		OPT__ABBREV(&abbrev),
+		OPT_END()
+	};
+	struct option *options;
+	const char * const *help_usage;
 
+	if (!strcmp(argv[0], "list-files")) {
+		help_usage = ls_usage;
+		options = builtin_ls_options;
+		porcelain = 1;
+	} else {
+		help_usage = ls_files_usage;
+		options = builtin_ls_files_options;
+	}
 	if (argc == 2 && !strcmp(argv[1], "-h"))
-		usage_with_options(ls_files_usage, builtin_ls_files_options);
+		usage_with_options(help_usage, options);
 
 	memset(&dir, 0, sizeof(dir));
 	prefix = cmd_prefix;
 	if (prefix)
 		prefix_len = strlen(prefix);
-	git_config(git_default_config, NULL);
+
+	if (porcelain) {
+		setenv(GIT_GLOB_PATHSPECS_ENVIRONMENT, "1", 1);
+		exc_given = 1;
+		setup_standard_excludes(&dir);
+		use_color = -1;
+		max_depth = 0;
+		git_config(git_ls_config, NULL);
+	} else
+		git_config(git_default_config, NULL);
 
 	if (read_cache() < 0)
 		die("index file corrupt");
 
-	argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
-			ls_files_usage, 0);
+	argc = parse_options(argc, argv, prefix, options, help_usage, 0);
 	el = add_exclude_list(&dir, EXC_CMDL, "--exclude option");
 	for (i = 0; i < exclude_list.nr; i++) {
 		add_exclude(exclude_list.items[i].string, "", 0, el, --exclude_args);
@@ -661,6 +718,10 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			die("ls-files --with-tree is incompatible with -s or -u");
 		overlay_tree_on_cache(with_tree, max_prefix);
 	}
+	if (porcelain) {
+		refresh_index(&the_index, REFRESH_QUIET, &pathspec, NULL, NULL);
+		setup_pager();
+	}
 	show_files(&dir);
 	if (show_resolve_undo)
 		show_ru_info();
diff --git a/command-list.txt b/command-list.txt
index cf36c3d..bfaca46 100644
--- a/command-list.txt
+++ b/command-list.txt
@@ -63,6 +63,7 @@ git-index-pack                          plumbingmanipulators
 git-init                                mainporcelain common
 git-instaweb                            ancillaryinterrogators
 gitk                                    mainporcelain
+git-list-files                          mainporcelain
 git-log                                 mainporcelain common
 git-ls-files                            plumbinginterrogators
 git-ls-remote                           plumbinginterrogators
diff --git a/git.c b/git.c
index 9efd1a3..8b46e92 100644
--- a/git.c
+++ b/git.c
@@ -380,6 +380,7 @@ static struct cmd_struct commands[] = {
 	{ "index-pack", cmd_index_pack, RUN_SETUP_GENTLY },
 	{ "init", cmd_init_db },
 	{ "init-db", cmd_init_db },
+	{ "list-files", cmd_ls_files, RUN_SETUP },
 	{ "log", cmd_log, RUN_SETUP },
 	{ "ls-files", cmd_ls_files, RUN_SETUP },
 	{ "ls-remote", cmd_ls_remote, RUN_SETUP_GENTLY },
-- 
1.9.1.345.ga1a145c

[PATCH v3 10/18] list-files: -u does not imply showing stages

[Nguyễn Thái Ngọc Duy]

Showing full index entry information is something for ls-files
only. The users of "git list-files" may just want to know what entries
are not unmerged.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 0ae07b0..addbcce 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -656,7 +656,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	}
 	if (show_modified || show_others || show_deleted || (dir.flags & DIR_SHOW_IGNORED) || show_killed)
 		require_work_tree = 1;
-	if (show_unmerged)
+	if (show_unmerged && !porcelain)
 		/*
 		 * There's no point in showing unmerged unless
 		 * you also show the stage information.
-- 
1.9.1.345.ga1a145c

[PATCH v3 11/18] list-files: add -R/--recursive short for --max-depth=-1

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-list-files.txt | 4 ++++
 builtin/ls-files.c               | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/Documentation/git-list-files.txt b/Documentation/git-list-files.txt
index 3039e1e..5dccbbc 100644
--- a/Documentation/git-list-files.txt
+++ b/Documentation/git-list-files.txt
@@ -45,6 +45,10 @@ OPTIONS
 --unmerged::
 	Show unmerged files
 
+-R::
+--recursive::
+	Equivalent of `--max-depth=-1` (infinite recursion).
+
 --color[=<when>]::
 --no-color::
 	Color file names. The value must be `always`, `never`, or
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index addbcce..656b632 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -594,6 +594,8 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			N_("show cached files that have modification on working directory")),
 		OPT_BOOL('o', "others", &show_others,
 			N_("show untracked files")),
+		OPT_SET_INT('R', "recursive", &max_depth,
+			    N_("shortcut for --max-depth=-1"), -1),
 		OPT_BIT('i', "ignored", &dir.flags,
 			N_("show ignored files"),
 			DIR_SHOW_IGNORED),
-- 
1.9.1.345.ga1a145c

[PATCH v3 12/18] list-files: add -1 short for --no-column

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-list-files.txt | 3 +++
 builtin/ls-files.c               | 2 ++
 2 files changed, 5 insertions(+)

diff --git a/Documentation/git-list-files.txt b/Documentation/git-list-files.txt
index 5dccbbc..725a236 100644
--- a/Documentation/git-list-files.txt
+++ b/Documentation/git-list-files.txt
@@ -49,6 +49,9 @@ OPTIONS
 --recursive::
 	Equivalent of `--max-depth=-1` (infinite recursion).
 
+-1::
+	Equivalent of --no-column.
+
 --color[=<when>]::
 --no-color::
 	Color file names. The value must be `always`, `never`, or
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 656b632..db0ee6b 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -603,6 +603,8 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			N_("show unmerged files")),
 		OPT__COLOR(&use_color, N_("show color")),
 		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
+		OPT_SET_INT('1', NULL, &colopts,
+			    N_("shortcut for --no-column"), COL_PARSEOPT),
 		{ OPTION_INTEGER, 0, "max-depth", &max_depth, N_("depth"),
 			N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
 			NULL, 1 },
-- 
1.9.1.345.ga1a145c

[PATCH v3 13/18] list-files: add -t back

[Nguyễn Thái Ngọc Duy]

Tag "H" (cached) is not shown though because it's usually the majority
and becomes noise. Not showing it makes the other tags stand out. -t
is on by default if more than one file category is selected.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-list-files.txt |  6 ++++++
 builtin/ls-files.c               | 27 +++++++++++++++++----------
 2 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/Documentation/git-list-files.txt b/Documentation/git-list-files.txt
index 725a236..0ef616b 100644
--- a/Documentation/git-list-files.txt
+++ b/Documentation/git-list-files.txt
@@ -45,6 +45,12 @@ OPTIONS
 --unmerged::
 	Show unmerged files
 
+-t::
+--[no-]tag::
+	Show a tag to indicate file type. Automatically turned on with
+	multiple file selections. See linkgit::git-ls-files[1] option
+	`-t` for more information.
+
 -R::
 --recursive::
 	Equivalent of `--max-depth=-1` (infinite recursion).
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index db0ee6b..14dfd2a 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -596,6 +596,8 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			N_("show untracked files")),
 		OPT_SET_INT('R', "recursive", &max_depth,
 			    N_("shortcut for --max-depth=-1"), -1),
+		OPT_BOOL('t', "tag", &show_tag,
+			N_("identify the file status with tags")),
 		OPT_BIT('i', "ignored", &dir.flags,
 			N_("show ignored files"),
 			DIR_SHOW_IGNORED),
@@ -636,6 +638,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		setup_standard_excludes(&dir);
 		use_color = -1;
 		max_depth = 0;
+		show_tag = -1;
 		git_config(git_ls_config, NULL);
 	} else
 		git_config(git_default_config, NULL);
@@ -648,16 +651,6 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	for (i = 0; i < exclude_list.nr; i++) {
 		add_exclude(exclude_list.items[i].string, "", 0, el, --exclude_args);
 	}
-	if (show_tag || show_valid_bit) {
-		tag_cached = "H ";
-		tag_unmerged = "M ";
-		tag_removed = "R ";
-		tag_modified = "C ";
-		tag_other = "? ";
-		tag_killed = "K ";
-		tag_skip_worktree = "S ";
-		tag_resolve_undo = "U ";
-	}
 	if (show_modified || show_others || show_deleted || (dir.flags & DIR_SHOW_IGNORED) || show_killed)
 		require_work_tree = 1;
 	if (show_unmerged && !porcelain)
@@ -711,6 +704,20 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	      show_killed || show_modified || show_resolve_undo))
 		show_cached = 1;
 
+	if (show_tag == -1)
+		show_tag = (show_cached + show_deleted + show_others +
+			    show_unmerged + show_killed + show_modified) > 1;
+	if (show_tag || show_valid_bit) {
+		tag_cached = porcelain ? "  " : "H ";
+		tag_unmerged = "M ";
+		tag_removed = "R ";
+		tag_modified = "C ";
+		tag_other = "? ";
+		tag_killed = "K ";
+		tag_skip_worktree = "S ";
+		tag_resolve_undo = "U ";
+	}
+
 	if (max_prefix)
 		prune_cache(max_prefix);
 	if (with_tree) {
-- 
1.9.1.345.ga1a145c

[PATCH v3 14/18] list-files: sort output and remove duplicates

[Nguyễn Thái Ngọc Duy]

When you mix different file types, with ls-files you may get separate
listing. For example, "ls-files -cm" will show file "abc" twice: one
as part of cached list, one of modified list. With "ls" (and this
patch) they will be in a single sorted list (easier for the eye).

Duplicate entries are also removed. Note that display content is
compared, so if you have "-t" on, or you color file types differently,
you will get duplicate textual entries. This is good imo.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 36 ++++++++++++++++++++++++------------
 1 file changed, 24 insertions(+), 12 deletions(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 14dfd2a..ff2377f 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -53,6 +53,13 @@ static const char *tag_modified = "";
 static const char *tag_skip_worktree = "";
 static const char *tag_resolve_undo = "";
 
+static int compare_output(const void *a_, const void *b_)
+{
+	const struct string_list_item *a = a_;
+	const struct string_list_item *b = b_;
+	return strcmp(a->util, b->util);
+}
+
 static void write_name(struct strbuf *sb, const char *name)
 {
 	/*
@@ -68,10 +75,12 @@ static void write_name(struct strbuf *sb, const char *name)
 		quote_path_relative(name, real_prefix, sb);
 }
 
-static void strbuf_fputs(struct strbuf *sb, FILE *fp)
+static void strbuf_fputs(struct strbuf *sb, const char *full_name, FILE *fp)
 {
-	if (column_active(colopts)) {
-		string_list_append(&output, strbuf_detach(sb, NULL));
+	if (column_active(colopts) || porcelain) {
+		struct string_list_item *it;
+		it = string_list_append(&output, strbuf_detach(sb, NULL));
+		it->util = (void*)full_name;
 		return;
 	}
 	fwrite(sb->buf, sb->len, 1, fp);
@@ -106,7 +115,7 @@ static void show_dir_entry(const char *tag, struct dir_entry *ent)
 	strbuf_reset(&sb);
 	strbuf_addstr(&sb, tag);
 	write_dir_entry(&sb, ent);
-	strbuf_fputs(&sb, stdout);
+	strbuf_fputs(&sb, ent->name, stdout);
 }
 
 static void show_other_files(struct dir_struct *dir)
@@ -223,7 +232,7 @@ static void show_ce_entry(const char *tag, const struct cache_entry *ce)
 			    ce_stage(ce));
 	}
 	write_ce_name(&sb, ce);
-	strbuf_fputs(&sb, stdout);
+	strbuf_fputs(&sb, ce->name, stdout);
 	if (debug_mode) {
 		const struct stat_data *sd = &ce->ce_stat_data;
 
@@ -524,6 +533,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	const char *max_prefix;
 	struct dir_struct dir;
 	struct exclude_list *el;
+	struct column_options copts;
 	struct string_list exclude_list = STRING_LIST_INIT_NODUP;
 	struct option builtin_ls_files_options[] = {
 		{ OPTION_CALLBACK, 'z', NULL, NULL, NULL,
@@ -671,7 +681,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		if (debug_mode)
 			die(_("--column and --debug are incompatible"));
 	}
-	if (column_active(colopts))
+	if (column_active(colopts) || porcelain)
 		line_terminator = 0;
 
 	if (require_work_tree && !is_inside_work_tree())
@@ -737,13 +747,15 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 	if (show_resolve_undo)
 		show_ru_info();
 
-	if (column_active(colopts)) {
-		struct column_options copts;
-		memset(&copts, 0, sizeof(copts));
-		copts.padding = 2;
-		print_columns(&output, colopts, &copts);
-		string_list_clear(&output, 0);
+	memset(&copts, 0, sizeof(copts));
+	copts.padding = 2;
+	if (porcelain) {
+		qsort(output.items, output.nr, sizeof(*output.items),
+		      compare_output);
+		string_list_remove_duplicates(&output, 0);
 	}
+	print_columns(&output, colopts, &copts);
+	string_list_clear(&output, 0);
 
 	if (ps_matched) {
 		int bad;
-- 
1.9.1.345.ga1a145c

[PATCH v3 15/18] list-files: do not show duplicate cached entries

[Nguyễn Thái Ngọc Duy]

With the current show_files() "list-files -tcm" will show

  foo.c
M foo.c

The first item is redundant. If "foo.c" is modified, we know it's in
the cache. Introduce show_files_compact to do that because ls-files is
plumbing and scripts may already depend on current display behavior.

Another difference in show_files_compact() is it does not show
skip-worktree (aka outside sparse checkout) entries anymore, which
makes sense in porcelain context.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index ff2377f..9a8f687 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -333,6 +333,53 @@ static void show_files(struct dir_struct *dir)
 	}
 }
 
+static void show_files_compact(struct dir_struct *dir)
+{
+	int i;
+
+	/* For cached/deleted files we don't need to even do the readdir */
+	if (show_others || show_killed) {
+		if (!show_others)
+			dir->flags |= DIR_COLLECT_KILLED_ONLY;
+		fill_directory(dir, &pathspec);
+		if (show_others)
+			show_other_files(dir);
+		if (show_killed)
+			show_killed_files(dir);
+	}
+	if (!(show_cached || show_stage || show_deleted || show_modified))
+		return;
+	for (i = 0; i < active_nr; i++) {
+		const struct cache_entry *ce = active_cache[i];
+		struct stat st;
+		int err, shown = 0;
+		if ((dir->flags & DIR_SHOW_IGNORED) &&
+		    !ce_excluded(dir, ce))
+			continue;
+		if (show_unmerged && !ce_stage(ce))
+			continue;
+		if (ce->ce_flags & CE_UPDATE)
+			continue;
+		if (ce_skip_worktree(ce))
+			continue;
+		err = lstat(ce->name, &st);
+		if (show_deleted && err) {
+			show_ce_entry(tag_removed, ce);
+			shown = 1;
+		}
+		if (show_modified && (err || ce_modified(ce, &st, 0))) {
+			show_ce_entry(tag_modified, ce);
+			shown = 1;
+		}
+		if (ce_stage(ce)) {
+			show_ce_entry(tag_unmerged, ce);
+			shown = 1;
+		}
+		if (!shown && show_cached)
+			show_ce_entry(tag_cached, ce);
+	}
+}
+
 /*
  * Prune the index to only contain stuff starting with "prefix"
  */
@@ -743,7 +790,10 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		refresh_index(&the_index, REFRESH_QUIET, &pathspec, NULL, NULL);
 		setup_pager();
 	}
-	show_files(&dir);
+	if (porcelain)
+		show_files_compact(&dir);
+	else
+		show_files(&dir);
 	if (show_resolve_undo)
 		show_ru_info();
 
-- 
1.9.1.345.ga1a145c

[PATCH v3 16/18] list-files: show directories as well as files

[Nguyễn Thái Ngọc Duy]

The index does not store directories explicitly (except submodules) so
we have to figure them out from file list. The function
show_directories() deliberately generates duplicate directories and
expects the previous patch to remove duplicates.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 builtin/ls-files.c | 44 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 9a8f687..9dc1c39 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -27,6 +27,8 @@ static int show_resolve_undo;
 static int show_modified;
 static int show_killed;
 static int show_valid_bit;
+static int show_tag;
+static int show_dirs;
 static int line_terminator = '\n';
 static int debug_mode;
 static int use_color;
@@ -333,6 +335,43 @@ static void show_files(struct dir_struct *dir)
 	}
 }
 
+static void show_directories(const struct cache_entry *ce)
+{
+	static const char *last_directory;
+	struct strbuf sb = STRBUF_INIT;
+	const char *p = ce->name + prefix_len;
+	const char *sep;
+
+	if (last_directory) {
+		int len = strlen(last_directory);
+		if (!strncmp(ce->name, last_directory, len) &&
+		    ce->name[len] == '/')
+			p += len + 1;
+	}
+
+	while (*p && (sep = strchr(p, '/'))) {
+		struct strbuf sb2 = STRBUF_INIT;
+		strbuf_reset(&sb);
+		strbuf_add(&sb, ce->name, sep - ce->name);
+		p = sep + 1;
+		if (!match_pathspec(&pathspec, sb.buf, sb.len,
+				    prefix_len, NULL, 1))
+			continue;
+		write_name(&sb2, sb.buf);
+		if (want_color(use_color)) {
+			struct strbuf sb3 = STRBUF_INIT;
+			color_filename(&sb3, ce->name, sb2.buf, S_IFDIR, 1);
+			strbuf_release(&sb2);
+			sb2 = sb3;
+		}
+		if (show_tag)
+			strbuf_insert(&sb2, 0, tag_cached, strlen(tag_cached));
+		last_directory = strbuf_detach(&sb, NULL);
+		strbuf_fputs(&sb2, last_directory, NULL);
+		strbuf_release(&sb2);
+	}
+}
+
 static void show_files_compact(struct dir_struct *dir)
 {
 	int i;
@@ -353,6 +392,8 @@ static void show_files_compact(struct dir_struct *dir)
 		const struct cache_entry *ce = active_cache[i];
 		struct stat st;
 		int err, shown = 0;
+		if (show_dirs)
+			show_directories(ce);
 		if ((dir->flags & DIR_SHOW_IGNORED) &&
 		    !ce_excluded(dir, ce))
 			continue;
@@ -575,7 +616,7 @@ static int git_ls_config(const char *var, const char *value, void *cb)
 
 int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 {
-	int require_work_tree = 0, show_tag = 0, i;
+	int require_work_tree = 0, i;
 	int max_depth = -1;
 	const char *max_prefix;
 	struct dir_struct dir;
@@ -696,6 +737,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		use_color = -1;
 		max_depth = 0;
 		show_tag = -1;
+		show_dirs = 1;
 		git_config(git_ls_config, NULL);
 	} else
 		git_config(git_default_config, NULL);
-- 
1.9.1.345.ga1a145c

[PATCH v3 17/18] list-files: add -F/--classify

[Nguyễn Thái Ngọc Duy]

This appends an indicator after the file name if it's executable, a
directory and so on, like in GNU ls. In fact append_indicator() is a
rewrite from get_type_indicator() in coreutils.git commit
7326d1f1a67edf21947ae98194f98c38b6e9e527.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-list-files.txt |  6 ++++++
 builtin/ls-files.c               | 31 +++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+)

diff --git a/Documentation/git-list-files.txt b/Documentation/git-list-files.txt
index 0ef616b..22084eb 100644
--- a/Documentation/git-list-files.txt
+++ b/Documentation/git-list-files.txt
@@ -51,6 +51,12 @@ OPTIONS
 	multiple file selections. See linkgit::git-ls-files[1] option
 	`-t` for more information.
 
+-F::
+--classify::
+	Append indicator (one of `*/=>@|`, which is executable,
+	directory, socket, Solaris door, symlink, or fifo
+	respectively) to entries.
+
 -R::
 --recursive::
 	Equivalent of `--max-depth=-1` (infinite recursion).
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 9dc1c39..2d475f0 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -29,6 +29,7 @@ static int show_killed;
 static int show_valid_bit;
 static int show_tag;
 static int show_dirs;
+static int show_indicator;
 static int line_terminator = '\n';
 static int debug_mode;
 static int use_color;
@@ -77,6 +78,28 @@ static void write_name(struct strbuf *sb, const char *name)
 		quote_path_relative(name, real_prefix, sb);
 }
 
+static void append_indicator(struct strbuf *sb, mode_t mode)
+{
+	char c = 0;
+	if (S_ISREG(mode)) {
+		if (mode & (S_IXUSR | S_IXGRP | S_IXOTH))
+			c = '*';
+	} else if (S_ISDIR(mode))
+		c = '/';
+	else if (S_ISLNK(mode))
+		c = '@';
+	else if (S_ISFIFO(mode))
+		c = '|';
+	else if (S_ISSOCK(mode))
+		c = '=';
+#ifdef S_ISDOOR
+	else if (S_ISDOOR(mode))
+		c = '>';
+#endif
+	if (c)
+		strbuf_addch(sb, c);
+}
+
 static void strbuf_fputs(struct strbuf *sb, const char *full_name, FILE *fp)
 {
 	if (column_active(colopts) || porcelain) {
@@ -99,6 +122,8 @@ static void write_dir_entry(struct strbuf *sb, const struct dir_entry *ent)
 		color_filename(sb, ent->name, quoted.buf, st.st_mode, 1);
 	else
 		strbuf_addbuf(sb, &quoted);
+	if (show_indicator && st.st_mode)
+		append_indicator(sb, st.st_mode);
 	strbuf_addch(sb, line_terminator);
 	strbuf_release(&quoted);
 }
@@ -189,6 +214,8 @@ static void write_ce_name(struct strbuf *sb, const struct cache_entry *ce)
 		color_filename(sb, ce->name, quoted.buf, ce->ce_mode, 1);
 	else
 		strbuf_addbuf(sb, &quoted);
+	if (show_indicator)
+		append_indicator(sb, ce->ce_mode);
 	strbuf_addch(sb, line_terminator);
 	strbuf_release(&quoted);
 }
@@ -366,6 +393,8 @@ static void show_directories(const struct cache_entry *ce)
 		}
 		if (show_tag)
 			strbuf_insert(&sb2, 0, tag_cached, strlen(tag_cached));
+		if (show_indicator)
+			append_indicator(&sb2, S_IFDIR);
 		last_directory = strbuf_detach(&sb, NULL);
 		strbuf_fputs(&sb2, last_directory, NULL);
 		strbuf_release(&sb2);
@@ -701,6 +730,8 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 			DIR_SHOW_IGNORED),
 		OPT_BOOL('u', "unmerged", &show_unmerged,
 			N_("show unmerged files")),
+		OPT_BOOL('F', "classify", &show_indicator,
+			 N_("append indicator (one of */=>@|) to entries")),
 		OPT__COLOR(&use_color, N_("show color")),
 		OPT_COLUMN(0, "column", &colopts, N_("show files in columns")),
 		OPT_SET_INT('1', NULL, &colopts,
-- 
1.9.1.345.ga1a145c

[PATCH v3 18/18] list-files -F: show submodules with the new indicator '&'

[Nguyễn Thái Ngọc Duy]

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
---
 Documentation/git-list-files.txt | 4 ++--
 builtin/ls-files.c               | 2 ++
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/Documentation/git-list-files.txt b/Documentation/git-list-files.txt
index 22084eb..c57129b 100644
--- a/Documentation/git-list-files.txt
+++ b/Documentation/git-list-files.txt
@@ -53,8 +53,8 @@ OPTIONS
 
 -F::
 --classify::
-	Append indicator (one of `*/=>@|`, which is executable,
-	directory, socket, Solaris door, symlink, or fifo
+	Append indicator (one of `*/=>@|&`, which is executable,
+	directory, socket, Solaris door, symlink, fifo, or submodule
 	respectively) to entries.
 
 -R::
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 2d475f0..f3e34db 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -92,6 +92,8 @@ static void append_indicator(struct strbuf *sb, mode_t mode)
 		c = '|';
 	else if (S_ISSOCK(mode))
 		c = '=';
+	else if (S_ISGITLINK(mode))
+		c = '&';
 #ifdef S_ISDOOR
 	else if (S_ISDOOR(mode))
 		c = '>';
-- 
1.9.1.345.ga1a145c

Re: [PATCH] ls-files: do not trust stat info if lstat() fails

[Junio C Hamano]

Nguyễn Thái Ngọc Duy <pclouds@gmail.com> writes:

> If 'err' is non-zero, lstat() has failed. Consider the entry modified
> without passing the (unreliable) stat info to ce_modified() in this
> case.
>
> Noticed-by: Eric Sunshine <sunshine@sunshineco.com>
> Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
> ---
>  On Fri, Mar 28, 2014 at 11:04 AM, Eric Sunshine <sunshine@sunshineco.com> wrote:
>  > On Wed, Mar 26, 2014 at 9:48 AM, Nguyễn Thái Ngọc Duy <pclouds@gmail.com> wrote:
>  >> +               err = lstat(ce->name, &st);
>  >> +               if (show_deleted && err) {
>  >> +                       show_ce_entry(tag_removed, ce);
>  >> +                       shown = 1;
>  >> +               }
>  >> +               if (show_modified && ce_modified(ce, &st, 0)) {
>  >
>  > Is it possible for the lstat() to have failed for some reason when we
>  > get here? If so, relying upon 'st' is unsafe, isn't it?
>
>  The chance of random stat making ce_modified() return false is pretty
>  low, but you're right. This code is a copy from the old show_files().
>  I'll fix it in the git-ls series. Meanwhile a patch for maint to fix
>  the original function.
>
>  builtin/ls-files.c | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/builtin/ls-files.c b/builtin/ls-files.c
> index 47c3880..e6bd00e 100644
> --- a/builtin/ls-files.c
> +++ b/builtin/ls-files.c
> @@ -260,7 +260,7 @@ static void show_files(struct dir_struct *dir)
>  			err = lstat(ce->name, &st);
>  			if (show_deleted && err)
>  				show_ce_entry(tag_removed, ce);
> -			if (show_modified && ce_modified(ce, &st, 0))
> +			if (show_modified && (err || ce_modified(ce, &st, 0)))
>  				show_ce_entry(tag_modified, ce);
>  		}
>  	}

I am guessing that, even though this was discovered during the
development of list-files, is a fix applicable outside the context
of that series.

I do think the patched result is an improvement than the status quo,
but at the same time, I find it insufficient in the context of the
whole codepath.  What if errno were other than ENOENT and we were
told to show_deleted (with or without show_modified)?  We would end
up saying the path was deleted and modified at the same time, when
we do not know either is or is not true at all, because of the
failure to lstat() the path.

Wouldn't it be saner to add tag_unknown and do something like this
instead, I wonder?

 builtin/ls-files.c | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 47c3880..af2ce99 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -46,6 +46,7 @@ static const char *tag_killed = "";
 static const char *tag_modified = "";
 static const char *tag_skip_worktree = "";
 static const char *tag_resolve_undo = "";
+static const char *tag_unknown = "";
 
 static void write_name(const char *name)
 {
@@ -249,7 +250,7 @@ static void show_files(struct dir_struct *dir)
 		for (i = 0; i < active_nr; i++) {
 			const struct cache_entry *ce = active_cache[i];
 			struct stat st;
-			int err;
+
 			if ((dir->flags & DIR_SHOW_IGNORED) &&
 			    !ce_excluded(dir, ce))
 				continue;
@@ -257,11 +258,15 @@ static void show_files(struct dir_struct *dir)
 				continue;
 			if (ce_skip_worktree(ce))
 				continue;
-			err = lstat(ce->name, &st);
-			if (show_deleted && err)
-				show_ce_entry(tag_removed, ce);
-			if (show_modified && ce_modified(ce, &st, 0))
+			errno = 0;
+			if (lstat(ce->name, &st)) {
+				if (errno != ENOENT && errno != ENOTDIR)
+					show_ce_entry(tag_unknown, ce);
+				else if (show_deleted)
+					show_ce_entry(tag_removed, ce);
+			} else if (show_modified && ce_modified(ce, &st, 0)) {
 				show_ce_entry(tag_modified, ce);
+			}
 		}
 	}
 }
@@ -533,6 +538,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
 		tag_killed = "K ";
 		tag_skip_worktree = "S ";
 		tag_resolve_undo = "U ";
+		tag_unknown = "! ";
 	}
 	if (show_modified || show_others || show_deleted || (dir.flags & DIR_SHOW_IGNORED) || show_killed)
 		require_work_tree = 1;

Re: [PATCH] ls-files: do not trust stat info if lstat() fails

[Duy Nguyen]

On Thu, Apr 3, 2014 at 1:15 AM, Junio C Hamano <gitster@pobox.com> wrote:
> I am guessing that, even though this was discovered during the
> development of list-files, is a fix applicable outside the context
> of that series.
>
> I do think the patched result is an improvement than the status quo,
> but at the same time, I find it insufficient in the context of the
> whole codepath.  What if errno were other than ENOENT and we were
> told to show_deleted (with or without show_modified)?  We would end
> up saying the path was deleted and modified at the same time, when
> we do not know either is or is not true at all, because of the
> failure to lstat() the path.
>
> Wouldn't it be saner to add tag_unknown and do something like this
> instead, I wonder?

Or even better to show an error message when the error code is
unexpected? The unkown tag '!' says "there are problems" but if it
shows up sort of permanently, '!' won't help much, I think.
-- 
Duy

Re: [PATCH] ls-files: do not trust stat info if lstat() fails

[Junio C Hamano]

Duy Nguyen <pclouds@gmail.com> writes:

> On Thu, Apr 3, 2014 at 1:15 AM, Junio C Hamano <gitster@pobox.com> wrote:
>> I am guessing that, even though this was discovered during the
>> development of list-files, is a fix applicable outside the context
>> of that series.
>>
>> I do think the patched result is an improvement than the status quo,
>> but at the same time, I find it insufficient in the context of the
>> whole codepath.  What if errno were other than ENOENT and we were
>> told to show_deleted (with or without show_modified)?  We would end
>> up saying the path was deleted and modified at the same time, when
>> we do not know either is or is not true at all, because of the
>> failure to lstat() the path.
>>
>> Wouldn't it be saner to add tag_unknown and do something like this
>> instead, I wonder?
>
> Or even better to show an error message when the error code is
> unexpected? The unkown tag '!' says "there are problems" but if it
> shows up sort of permanently, '!' won't help much, I think.

I am OK with that approach, but then one question remains: should we
say it is deleted, modified, both, or neither?

Re: [PATCH] ls-files: do not trust stat info if lstat() fails

[Duy Nguyen]

On Thu, Apr 3, 2014 at 11:30 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Duy Nguyen <pclouds@gmail.com> writes:
>
>> On Thu, Apr 3, 2014 at 1:15 AM, Junio C Hamano <gitster@pobox.com> wrote:
>>> I am guessing that, even though this was discovered during the
>>> development of list-files, is a fix applicable outside the context
>>> of that series.
>>>
>>> I do think the patched result is an improvement than the status quo,
>>> but at the same time, I find it insufficient in the context of the
>>> whole codepath.  What if errno were other than ENOENT and we were
>>> told to show_deleted (with or without show_modified)?  We would end
>>> up saying the path was deleted and modified at the same time, when
>>> we do not know either is or is not true at all, because of the
>>> failure to lstat() the path.
>>>
>>> Wouldn't it be saner to add tag_unknown and do something like this
>>> instead, I wonder?
>>
>> Or even better to show an error message when the error code is
>> unexpected? The unkown tag '!' says "there are problems" but if it
>> shows up sort of permanently, '!' won't help much, I think.
>
> I am OK with that approach, but then one question remains: should we
> say it is deleted, modified, both, or neither?

The question is moot if the user does not ignore stderr because they
should just ignore those error-reported entries. If they do
2>/dev/null, I think we should err on the safe side and say modified.
We only say deleted if lstat() returns ENOENT or ENOTDIR like in your
patch.
-- 
Duy

Re: [PATCH] ls-files: do not trust stat info if lstat() fails

[Junio C Hamano]

Duy Nguyen <pclouds@gmail.com> writes:

>>> Or even better to show an error message when the error code is
>>> unexpected? The unkown tag '!' says "there are problems" but if it
>>> shows up sort of permanently, '!' won't help much, I think.
>>
>> I am OK with that approach, but then one question remains: should we
>> say it is deleted, modified, both, or neither?
>
> The question is moot if the user does not ignore stderr because they
> should just ignore those error-reported entries. If they do
> 2>/dev/null, I think we should err on the safe side and say modified.
> We only say deleted if lstat() returns ENOENT or ENOTDIR like in your
> patch.

Doesn't the same reasoning behind "when we do not know for sure that
a path is not modified, it would be safe if we said the path may be
modified" also tell us that it is safer to say a path may be lost if
we cannot tell?

One likely case where we cannot tell if it is modified would be when
we cannot read the path (perhaps the parent directory accidentally
lost its x-bit).  Saying "it may be modified" would be one way to
have the user take notice, for an interactive user.  A script that
runs ls-files may be using the paths to drive "git add", "tar cf -",
etc. and emitting such an unreadable path is one way to make these
downstream commands signal that something fishy is going on by
erroring out.

So, I am not sure if we should be silent on an unexpected error when
we are asked to report deletes when we would be vocal when we are
asked to report modifications.