| blob | 07c6589e74fa5afbff9bdfd8d7b7b41f873a005b |
1 diff a/Documentation/git-ls-tree.txt b/Documentation/git-ls-tree.txt
2 --- a/Documentation/git-ls-tree.txt
3 +++ b/Documentation/git-ls-tree.txt
4 @@ -4,23 +4,26 @@ v0.1, May 2005
6 NAME
7 ----
8 -git-ls-tree - Displays a tree object in human readable form
9 +git-ls-tree - Lists the contents of a tree object.
12 SYNOPSIS
13 --------
14 -'git-ls-tree' [-r] [-z] <tree-ish> [paths...]
15 +'git-ls-tree' [-d] [-r] [-z] <tree-ish> [paths...]
17 DESCRIPTION
18 -----------
19 -Converts the tree object to a human readable (and script processable)
20 -form.
21 +Lists the contents of a tree object, like what "/bin/ls -a" does
22 +in the current working directory.
24 OPTIONS
25 -------
26 <tree-ish>::
27 Id of a tree.
29 +-d::
30 + show only the named tree entry itself, not its children
31 +
32 -r::
33 recurse into sub-trees
35 @@ -28,18 +31,19 @@ OPTIONS
36 \0 line termination on output
38 paths::
39 - Optionally, restrict the output of git-ls-tree to specific
40 - paths. Directories will only list their tree blob ids.
41 - Implies -r.
42 + When paths are given, shows them. Otherwise implicitly
43 + uses the root level of the tree as the sole path argument.
44 +
46 Output Format
47 -------------
48 - <mode>\t <type>\t <object>\t <file>
49 + <mode> SP <type> SP <object> TAB <file>
52 Author
53 ------
54 Written by Linus Torvalds <torvalds@osdl.org>
55 +Completely rewritten from scratch by Junio C Hamano <junkio@cox.net>
57 Documentation
58 --------------
59 diff a/ls-tree.c b/ls-tree.c
60 --- a/ls-tree.c
61 +++ b/ls-tree.c
62 @@ -4,188 +4,217 @@
63 * Copyright (C) Linus Torvalds, 2005
64 */
65 #include "cache.h"
66 +#include "blob.h"
67 +#include "tree.h"
69 static int line_termination = '\n';
70 -static int recursive = 0;
71 +#define LS_RECURSIVE 1
72 +#define LS_TREE_ONLY 2
73 +static int ls_options = 0;
75 -struct path_prefix {
76 - struct path_prefix *prev;
77 - const char *name;
78 -};
79 -
80 -#define DEBUG(fmt, ...)
81 -
82 -static int string_path_prefix(char *buff, size_t blen, struct path_prefix *prefix)
83 -{
84 - int len = 0;
85 - if (prefix) {
86 - if (prefix->prev) {
87 - len = string_path_prefix(buff,blen,prefix->prev);
88 - buff += len;
89 - blen -= len;
90 - if (blen > 0) {
91 - *buff = '/';
92 - len++;
93 - buff++;
94 - blen--;
95 - }
96 - }
97 - strncpy(buff,prefix->name,blen);
98 - return len + strlen(prefix->name);
99 - }
100 +static struct tree_entry_list root_entry;
102 - return 0;
103 +static void prepare_root(unsigned char *sha1)
104 +{
105 + unsigned char rsha[20];
106 + unsigned long size;
107 + void *buf;
108 + struct tree *root_tree;
109 +
110 + buf = read_object_with_reference(sha1, "tree", &size, rsha);
111 + free(buf);
112 + if (!buf)
113 + die("Could not read %s", sha1_to_hex(sha1));
114 +
115 + root_tree = lookup_tree(rsha);
116 + if (!root_tree)
117 + die("Could not read %s", sha1_to_hex(sha1));
118 +
119 + /* Prepare a fake entry */
120 + root_entry.directory = 1;
121 + root_entry.executable = root_entry.symlink = 0;
122 + root_entry.mode = S_IFDIR;
123 + root_entry.name = "";
124 + root_entry.item.tree = root_tree;
125 + root_entry.parent = NULL;
126 }
128 -static void print_path_prefix(struct path_prefix *prefix)
129 +static int prepare_children(struct tree_entry_list *elem)
130 {
131 - if (prefix) {
132 - if (prefix->prev) {
133 - print_path_prefix(prefix->prev);
134 - putchar('/');
135 - }
136 - fputs(prefix->name, stdout);
137 + if (!elem->directory)
138 + return -1;
139 + if (!elem->item.tree->object.parsed) {
140 + struct tree_entry_list *e;
141 + if (parse_tree(elem->item.tree))
142 + return -1;
143 + /* Set up the parent link */
144 + for (e = elem->item.tree->entries; e; e = e->next)
145 + e->parent = elem;
146 }
147 + return 0;
148 }
150 -/*
151 - * return:
152 - * -1 if prefix is *not* a subset of path
153 - * 0 if prefix == path
154 - * 1 if prefix is a subset of path
155 - */
156 -static int pathcmp(const char *path, struct path_prefix *prefix)
157 -{
158 - char buff[PATH_MAX];
159 - int len,slen;
160 +static struct tree_entry_list *find_entry_0(struct tree_entry_list *elem,
161 + const char *path,
162 + const char *path_end)
163 +{
164 + const char *ep;
165 + int len;
166 +
167 + while (path < path_end) {
168 + if (prepare_children(elem))
169 + return NULL;
171 - if (prefix == NULL)
172 - return 1;
173 + /* In elem->tree->entries, find the one that has name
174 + * that matches what is between path and ep.
175 + */
176 + elem = elem->item.tree->entries;
178 - len = string_path_prefix(buff, sizeof buff, prefix);
179 - slen = strlen(path);
180 + ep = strchr(path, '/');
181 + if (!ep || path_end <= ep)
182 + ep = path_end;
183 + len = ep - path;
184 +
185 + while (elem) {
186 + if ((strlen(elem->name) == len) &&
187 + !strncmp(elem->name, path, len))
188 + break;
189 + elem = elem->next;
190 + }
191 + if (path_end <= ep || !elem)
192 + return elem;
193 + while (*ep == '/' && ep < path_end)
194 + ep++;
195 + path = ep;
196 + }
197 + return NULL;
198 +}
200 - if (slen < len)
201 - return -1;
202 +static struct tree_entry_list *find_entry(const char *path,
203 + const char *path_end)
204 +{
205 + /* Find tree element, descending from root, that
206 + * corresponds to the named path, lazily expanding
207 + * the tree if possible.
208 + */
209 + if (path == path_end) {
210 + /* Special. This is the root level */
211 + return &root_entry;
212 + }
213 + return find_entry_0(&root_entry, path, path_end);
214 +}
216 - if (strncmp(path,buff,len) == 0) {
217 - if (slen == len)
218 - return 0;
219 - else
220 - return 1;
221 +static void show_entry_name(struct tree_entry_list *e)
222 +{
223 + /* This is yucky. The root level is there for
224 + * our convenience but we really want to do a
225 + * forest.
226 + */
227 + if (e->parent && e->parent != &root_entry) {
228 + show_entry_name(e->parent);
229 + putchar('/');
230 }
231 + printf("%s", e->name);
232 +}
234 - return -1;
235 -}
236 +static const char *entry_type(struct tree_entry_list *e)
237 +{
238 + return (e->directory ? "tree" : "blob");
239 +}
241 -/*
242 - * match may be NULL, or a *sorted* list of paths
243 - */
244 -static void list_recursive(void *buffer,
245 - const char *type,
246 - unsigned long size,
247 - struct path_prefix *prefix,
248 - char **match, int matches)
249 -{
250 - struct path_prefix this_prefix;
251 - this_prefix.prev = prefix;
252 -
253 - if (strcmp(type, "tree"))
254 - die("expected a 'tree' node");
255 -
256 - if (matches)
257 - recursive = 1;
258 -
259 - while (size) {
260 - int namelen = strlen(buffer)+1;
261 - void *eltbuf = NULL;
262 - char elttype[20];
263 - unsigned long eltsize;
264 - unsigned char *sha1 = buffer + namelen;
265 - char *path = strchr(buffer, ' ') + 1;
266 - unsigned int mode;
267 - const char *matched = NULL;
268 - int mtype = -1;
269 - int mindex;
270 -
271 - if (size < namelen + 20 || sscanf(buffer, "%o", &mode) != 1)
272 - die("corrupt 'tree' file");
273 - buffer = sha1 + 20;
274 - size -= namelen + 20;
275 -
276 - this_prefix.name = path;
277 - for ( mindex = 0; mindex < matches; mindex++) {
278 - mtype = pathcmp(match[mindex],&this_prefix);
279 - if (mtype >= 0) {
280 - matched = match[mindex];
281 - break;
282 - }
283 - }
284 +static const char *entry_hex(struct tree_entry_list *e)
285 +{
286 + return sha1_to_hex(e->directory
287 + ? e->item.tree->object.sha1
288 + : e->item.blob->object.sha1);
289 +}
291 - /*
292 - * If we're not matching, or if this is an exact match,
293 - * print out the info
294 - */
295 - if (!matches || (matched != NULL && mtype == 0)) {
296 - printf("%06o %s %s\t", mode,
297 - S_ISDIR(mode) ? "tree" : "blob",
298 - sha1_to_hex(sha1));
299 - print_path_prefix(&this_prefix);
300 - putchar(line_termination);
301 - }
302 +/* forward declaration for mutually recursive routines */
303 +static int show_entry(struct tree_entry_list *, int);
305 - if (! recursive || ! S_ISDIR(mode))
306 - continue;
307 +static int show_children(struct tree_entry_list *e, int level)
308 +{
309 + if (prepare_children(e))
310 + die("internal error: ls-tree show_children called with non tree");
311 + e = e->item.tree->entries;
312 + while (e) {
313 + show_entry(e, level);
314 + e = e->next;
315 + }
316 + return 0;
317 +}
319 - if (matches && ! matched)
320 - continue;
321 +static int show_entry(struct tree_entry_list *e, int level)
322 +{
323 + int err = 0;
325 - if (! (eltbuf = read_sha1_file(sha1, elttype, &eltsize)) ) {
326 - error("cannot read %s", sha1_to_hex(sha1));
327 - continue;
328 - }
329 + if (e != &root_entry) {
330 + printf("%06o %s %s ", e->mode, entry_type(e),
331 + entry_hex(e));
332 + show_entry_name(e);
333 + putchar(line_termination);
334 + }
336 - /* If this is an exact directory match, we may have
337 - * directory files following this path. Match on them.
338 - * Otherwise, we're at a pach subcomponent, and we need
339 - * to try to match again.
340 + if (e->directory) {
341 + /* If this is a directory, we have the following cases:
342 + * (1) This is the top-level request (explicit path from the
343 + * command line, or "root" if there is no command line).
344 + * a. Without any flag. We show direct children. We do not
345 + * recurse into them.
346 + * b. With -r. We do recurse into children.
347 + * c. With -d. We do not recurse into children.
348 + * (2) We came here because our caller is either (1-a) or
349 + * (1-b).
350 + * a. Without any flag. We do not show our children (which
351 + * are grandchildren for the original request).
352 + * b. With -r. We continue to recurse into our children.
353 + * c. With -d. We should not have come here to begin with.
354 */
355 - if (mtype == 0)
356 - mindex++;
357 -
358 - list_recursive(eltbuf, elttype, eltsize, &this_prefix, &match[mindex], matches-mindex);
359 - free(eltbuf);
360 + if (level == 0 && !(ls_options & LS_TREE_ONLY))
361 + /* case (1)-a and (1)-b */
362 + err = err | show_children(e, level+1);
363 + else if (level && ls_options & LS_RECURSIVE)
364 + /* case (2)-b */
365 + err = err | show_children(e, level+1);
366 }
367 + return err;
368 }
370 -static int qcmp(const void *a, const void *b)
371 +static int list_one(const char *path, const char *path_end)
372 {
373 - return strcmp(*(char **)a, *(char **)b);
374 + int err = 0;
375 + struct tree_entry_list *e = find_entry(path, path_end);
376 + if (!e) {
377 + /* traditionally ls-tree does not complain about
378 + * missing path. We may change this later to match
379 + * what "/bin/ls -a" does, which is to complain.
380 + */
381 + return err;
382 + }
383 + err = err | show_entry(e, 0);
384 + return err;
385 }
387 -static int list(unsigned char *sha1,char **path)
388 +static int list(char **path)
389 {
390 - void *buffer;
391 - unsigned long size;
392 - int npaths;
393 -
394 - for (npaths = 0; path[npaths] != NULL; npaths++)
395 - ;
396 -
397 - qsort(path,npaths,sizeof(char *),qcmp);
398 -
399 - buffer = read_object_with_reference(sha1, "tree", &size, NULL);
400 - if (!buffer)
401 - die("unable to read sha1 file");
402 - list_recursive(buffer, "tree", size, NULL, path, npaths);
403 - free(buffer);
404 - return 0;
405 + int i;
406 + int err = 0;
407 + for (i = 0; path[i]; i++) {
408 + int len = strlen(path[i]);
409 + while (0 <= len && path[i][len] == '/')
410 + len--;
411 + err = err | list_one(path[i], path[i] + len);
412 + }
413 + return err;
414 }
416 -static const char *ls_tree_usage = "git-ls-tree [-r] [-z] <key> [paths...]";
417 +static const char *ls_tree_usage =
418 + "git-ls-tree [-d] [-r] [-z] <tree-ish> [path...]";
420 int main(int argc, char **argv)
421 {
422 + static char *path0[] = { "", NULL };
423 + char **path;
424 unsigned char sha1[20];
426 while (1 < argc && argv[1][0] == '-') {
427 @@ -194,7 +223,10 @@ int main(int argc, char **argv)
428 line_termination = 0;
429 break;
430 case 'r':
431 - recursive = 1;
432 + ls_options |= LS_RECURSIVE;
433 + break;
434 + case 'd':
435 + ls_options |= LS_TREE_ONLY;
436 break;
437 default:
438 usage(ls_tree_usage);
439 @@ -206,7 +238,10 @@ int main(int argc, char **argv)
440 usage(ls_tree_usage);
441 if (get_sha1(argv[1], sha1) < 0)
442 usage(ls_tree_usage);
443 - if (list(sha1, &argv[2]) < 0)
444 +
445 + path = (argc == 2) ? path0 : (argv + 2);
446 + prepare_root(sha1);
447 + if (list(path) < 0)
448 die("list failed");
449 return 0;
450 }
451 diff a/t/t3100-ls-tree-restrict.sh b/t/t3100-ls-tree-restrict.sh
452 --- a/t/t3100-ls-tree-restrict.sh
453 +++ b/t/t3100-ls-tree-restrict.sh
454 @@ -74,8 +74,8 @@ test_expect_success \
455 'ls-tree filtered' \
456 'git-ls-tree $tree path1 path0 >current &&
457 cat >expected <<\EOF &&
458 -100644 blob X path0
459 120000 blob X path1
460 +100644 blob X path0
461 EOF
462 test_output'
464 @@ -85,7 +85,6 @@ test_expect_success \
465 cat >expected <<\EOF &&
466 040000 tree X path2
467 040000 tree X path2/baz
468 -100644 blob X path2/baz/b
469 120000 blob X path2/bazbo
470 100644 blob X path2/foo
471 EOF
472 diff a/tree.c b/tree.c
473 --- a/tree.c
474 +++ b/tree.c
475 @@ -133,7 +133,7 @@ int parse_tree_buffer(struct tree *item,
476 }
477 if (obj)
478 add_ref(&item->object, obj);
479 -
480 + entry->parent = NULL; /* needs to be filled by the user */
481 *list_p = entry;
482 list_p = &entry->next;
483 }
484 diff a/tree.h b/tree.h
485 --- a/tree.h
486 +++ b/tree.h
487 @@ -16,6 +16,7 @@ struct tree_entry_list {
488 struct tree *tree;
489 struct blob *blob;
490 } item;
491 + struct tree_entry_list *parent;
492 };
494 struct tree {