I’m new at Git and GitHub, though I’ve been using Eclipse for years. I want to upload several of my personal Java projects to GitHub, but they form a complex tree of dependencies, which are all referenced using Eclipse project dependencies (i.e., each project has other Eclipse projects on its classpath). I’d like to avoid using Maven if possible (I use it at work, but it’s slow, buggy, and a PAIN, not to mention I’d have to run my own repository somewhere, separately from GitHub), and I’d prefer if the solution would allow users to compile the projects with or without Eclipse (possibly with Ant buildfiles or somesuch).
My question is: Is there some standard way to upload GitHub repositories with dependencies on other repositories? It seems like submodules are what I’m looking for, but would that create duplicates of every project inside every other project? Or is Maven really the best/only way to do this properly? I’d like it if users could just git clone or ant build and have all of the project’s dependencies downloaded and ready to compile, without mangling my project structure too badly.
An example of this setup: I have 3 Eclipse projects, A, B, and C. B and C are on A’s classpath, but A, B, and C are all in separate Git repositories. I would like a user to be able to git clone and ant build A, and, at some point in this process, have B and C automatically downloaded so that A will compile.
If I understand the question correctly, you want to split your project into multiple repositories, and then use some automatic mechanism to get all dependencies transitively either during git clone or during the build phase. For this reason, you want to encode this dependency information somewhere in the configuration.
I see basically three solutions for this issue (regardless of build technology):
Git submodules encode this information in the git repository. This way, you cannot checkout your projects without the dependencies. However, this may result in having the same repository downloaded multiple times, as you stated.
The alternative is to encode this information in the build system. In this case, you have a separate build for each repository, while all built binaries are put into a common repository (either a Maven or an Eclipse p2 repository, or even a central FTP storage might do); dependencies are queried from this central repository during build.
Or you could ask your user to ensure all required source projects are available (in Eclipse you can use a Team project set for this reason), and then build them together.
In my experience, solution 2 or 3 are the most common ones. If you can setup any kind of repository, it is the best way, as all your projects can be built and reused independently (that is a huge plus for plug-in projects). I am sure a p2 repository can be hosted in SVN or Git, as only HTTP requests are used to download the source. I believe, the same is possible for Maven repositories, but I have not seen such a repository working.
So, I suggest you build a p2 repository (can be done in Ant, but seems simpler in Maven Tycho), and split the projects to several repositories.