Re: Merge with git-pasky II.

CL> Then do you emit the entry for it's parents directory?

In GIT object model, directory modes do not matter. It is not designed to record directories, and running "update-cache --add foo" when foo is a directory fails.

The data model of GIT is that it associates file datablob to a string called "pathname" that happen to contain slashes in them. It is kinda wierd. When you externalize it with checkout-cache, these slashes are mapped to hierarchical UNIX filesystem paths, relative to whereever you happened to run checkout-cache. The hierarchical "tree" representation in the GIT database was started as just a space optimization thing.

CL> e.g. /foo/bar get created. foo doesn't exists. You have CL> to create foo first. You don't have mode information for CL> foo yet.

And you will never have that information, since it is not recorded anywhere. If I say you should have foo/bar (by the way, no leading slashes are placed in the dircache either), and if it so happens that you do not have foo yet, you'd better create one without waiting to be told, because I will never tell you to just create a directory.

By the way, Linus, while I was studying how the new hierarchical trees are written out, I think I have found one small funny (I would not call this a *bug*) there. Here is an excerpt from write-tree (around ll. 56; I am basing on pasky-0.4 so your line numbers may have some offsets):

        sha1 = ce->sha1;
        mode = ntohl(ce->st_mode);

        /* Do we have _further_ subdirectories? */
        filename = pathname + baselen;
        dirname = strchr(filename, '/');
        if (dirname) {
                int subdir_written;

                subdir_written = write_tree(cachep + nr, maxentries - nr, pathname, dirname-pathname+1, subdir_sha1);
                nr += subdir_written;

                /* Now we need to write out the directory entry into this tree.. */
                mode |= S_IFDIR;
                pathlen = dirname - pathname;

                /* ..but the directory entry doesn't count towards the total count */
                nr--;
                sha1 = subdir_sha1;
        }

This code is going through a flat list of cache entries sorted by pathnames. The list is flat in the sense that the pathnames are like "foo/bar" i.e. with slashes inside. The if() statement there, upon seeing "foo/bar", slurps all the entries in foo/ subhierarchy and writes into a separate tree, recursively, to "represent" foo/.

Notice what mode the "tree" object gets in this case? File mode for foo/bar (or whatever happens to be sorted the first among the stuff in dircache from foo/ directory) ORed with S_IFDIR. I think this is nonsense, and we should just store constant S_IFDIR.

Another option, probably better from the SCM purist's POV, would be to start recording directories in dircaches, so that people can actually keep track of directory modes. Does it matter? --- I would say not. GIT does not have to be tar or cpio.