Best practice for managing project variants in Git?

Question

I have to develop two Django projects which share 90% of the same code, but have some variations in several applications, templates and within the model itself.

I'm using Git for distributed source-control.

My requirements are that :

• common code for both projects is developed in one place (Project1's development environment)

• periodically this is merged into the development environment of the second project (Project2)

• the variations are not easily encapsulated within apps. (eg. there are apps. such as "profiles" which vary between Project1 and Project2 but for which there's also an ongoing common evolution)

• both Project1 and Project2 have public repositories, so that I can collaborate with others

• similarly Project1 and Project2 ought to have development, demo, staging and production servers.

• however, the public repository is not on the same server in both cases. So, for example, when I'm developing in Project1, I want to be able to "push" to my github server, but not have Project2 stuff going there.

• there are files such as local_settings.py which are completely different between Project1 and Project2, but should be shared between multiple developers of each Project

So what's the best way of managing this situation?

What would seem to be ideal would be something like a "filtered pull" where instead of .gitignore saying "ignore this file entirely", I can say "ignore this file when pulling from that repo" I couldn't see anything quite like that in the documentation, but might there be something like that?

Answer 1

I would make a third repo where I would place the code that Projects share. Then Project1 and Project2 would have their own repo and they can pull from that "shared" third repo.

I think that your idea of "filtered pull" will make it difficult to mantein.

Answer 2

Move the common code to its own library and make it a dependency of those two projects. This is not a question of version control, but a question of code reuse, design and eliminating duplication.

Answer 3

I would try submodules: http://www.kernel.org/pub/software/scm/git/docs/user-manual.html#submodules

Answer 4

Considering it is a Django / Pinax site, with variants scattered around inside several different applications, I would not recommend using submodules.

The variants should be managed independently in project1 branch and project2 branch, removing the need to "filter" a gitignore result.

If you identify some really common codes, they may end up in a third repo you could then "subtree merged" to project1 and project2 repositories (the meaning of subtree merge strategy being illustrated in this SO answer)

Answer 5

You can use two different git branches for development. When you make changes in one that are common to the other, just git-cherrypick them over. You can push and pull specific branches, too, so that no one ever need know you're working on both of them at the same time.