t/t4100/t-apply-7.patch

   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
   5
   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.
  10
  11
  12  SYNOPSIS
  13  --------
  14 -'git-ls-tree' [-r] [-z] <tree-ish> [paths...]
  15 +'git-ls-tree' [-d] [-r] [-z] <tree-ish> [paths...]
  16
  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.
  23
  24  OPTIONS
  25  -------
  26  <tree-ish>::
  27         Id of a tree.
  28
  29 +-d::
  30 +       show only the named tree entry itself, not its children
  31 +
  32  -r::
  33         recurse into sub-trees
  34
  35 @@ -28,18 +31,19 @@ OPTIONS
  36         \0 line termination on output
  37
  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 +
  45
  46  Output Format
  47  -------------
  48 -        <mode>\t       <type>\t        <object>\t      <file>
  49 +        <mode> SP <type> SP <object> TAB <file>
  50
  51
  52  Author
  53  ------
  54  Written by Linus Torvalds <torvalds@osdl.org>
  55 +Completely rewritten from scratch by Junio C Hamano <junkio@cox.net>
  56
  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"
  68
  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;
  74
  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;
 101
 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  }
 127
 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  }
 149
 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;
 170
 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;
 177
 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 +}
 199
 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 +}
 215
 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 +}
 233
 234 -       return -1;
 235 -}
 236 +static const char *entry_type(struct tree_entry_list *e)
 237 +{
 238 +       return (e->directory ? "tree" : "blob");
 239 +}
 240
 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 +}
 290
 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);
 304
 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 +}
 318
 319 -               if (matches && ! matched)
 320 -                       continue;
 321 +static int show_entry(struct tree_entry_list *e, int level)
 322 +{
 323 +       int err = 0;
 324
 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 +       }
 335
 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 patch 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  }
 369
 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  }
 386
 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  }
 415
 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...]";
 419
 420  int main(int argc, char **argv)
 421  {
 422 +       static char *path0[] = { "", NULL };
 423 +       char **path;
 424         unsigned char sha1[20];
 425
 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'
 463
 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  };
 493
 494  struct tree {