Re: [RFC] Submodules in GIT

hoi :)

On Fri, Dec 01, 2006 at 10:29:26AM +0000, Andy Parkins wrote:

On Friday 2006 December 01 09:57, Martin Waitz wrote:

quoted

So why do you need the url hint committed to the supermodule?
We don't store remote information in the object database, too.

That's why it was a hint, probably configured when you first create the 
submodule connection.

In truth, the clone will be perfectly able to get the submodule
objects from the upstream supermodule, maintaining the distributed
nature easily.

that's exactly the reason why the hint is not needed.
Althogh you need to have one common project object database, storing the
objects of all modules.

quoted

quoted

I say:
 submodulecommithash points at a commit /in the submodule/

But unluckily, this does not work.

Eh?  "Not work", we're talking about code that doesn't even exist, of
course it doesn't "work".   Do you mean "doesn't work if we're using
my implementation of submodules"?  Well that hardly seems like a fair
attack.

Well, at first I started exactly as you described: only store the
submodule commit sha1 in the parent somewhere, but don't traverse it.
So this is a fair attack: your implementation already exists in
http://git.admingilde.org/tali/git.git/module ;-)
(ok, yes, it really is different to what you described as I stored the
sha1 differently, but I really learned that it is important to be able
to traverse the entire commit chain, from the root of the project to the
deepest submodule.)

quoted

You really have to be able to traverse the entire commit chain
from the supermodule into all submodules.

You can: when you hit a submodule tree object you set GIT_DIR to that
submodule and continue.  If you don't do it like that then you have
stored submodule trees in the supermodule and it's no longer a
separate repository.

Well, a submodule repository _is_ special in some ways:
fsck and prune have to take the references from the supermodule into
account.  In this sense it is _not_ separate from the supermodule.

I think that is important for the submodule repository to be independent
in other ways than its object database:  you should be able to exchange
commits with other repositories (be they stand-alone or a submodule in
another supermodule).  You should be able to use log/diff/blame/whatever
inside the submodule.

All this does not need an object database of its own.
So I chose to do it the easy way and use one object database for the
entire project - and disallow git-prune in a submodule.
There may be other/better ways to do this, but you have to be able
to access all objects which belong the project inside the toplevel
project repository.

Why you'd want to - I have no idea.  What
purpose would you have for traversing the commit chain into the
submodules?  The commit in the submodule is just a note of where that
submodule was during the supermodule commit in question.

Things get much simpler if you have one big graph of objects.

clone and especially fetch/pull naturally work at once.
You can ask for all objects inside the whole project which are needed to
be transferred between project version A and B, including all submodules.

You can even have one bare repository for the whole project.

I notice though that you avoided my question: what does YOUR submodule
object contain?  I really do want to know, as there is obviously a
fundamental difference in what I think a submodule does and what you
(and maybe everybody else) thinks a submodule does.

It really only stores the commit of the submodule directly.
So there is no new submodule object type.  The parent has a direct link
to the submodule commit in his tree object and in its index.  In order
to separate them from normal files or normal subdirectories, they get a
special mode: they are represented as socket.

-- 
Martin Waitz