Question

I am struggling with figuring out a good method for handling my work flow using Mercurial. I have read many related questions here on SO and other places but couldn’t find a reasonable solution.

Suppose I have two branches:

1. the default branch I do normal development in. Deploying releases from and marking them with release tags
2. a branch for a specific customer that is maintained separately. It runs on a separate version number, branched from an older version of the application.

These two branches are mostly identical now but there are already some differences. Over time, they will drift apart more.

It means that I have 4 types of source files:

1. Type-A: Files that remain identical in both branches (changes, if introduced, should be present in both). These are most of the files.
2. Type-B: Files that are only in the default branch and do not need to be merged into the customer branch
3. Type-C: Files that are only in the customer branch and do not need to be merged into the default branch
4. Type-D: Files that are present in both branches, have shared code but also contain code that should remain separate and specific to each branch

Development done on the default branch and there are regular releases which are mostly incremental. But I also have these two scenarios:

1. Some changes done to the default branch, need to also be merged to the customer branch (e.g. a bug or feature that need to be fixed/added to both).
2. A “hotfix” done to the customer branch and cannot be immediately merged to the default branch but needs to be merged eventually at some point.

Problem is that I can’t figure out a reasonably simple, clean and safe way to support these two scenarios. Mercurial doesn’t have the concept of partial merges or ignoring files on merge. It merges changesets but it insists on including the files that were introduced in previous revisions.

Merging default into customer branch or customer into default in these scenarios forces me to add files of Type-B and Type-C. Making a change to file of Type-A that doesn’t need be added to the other branch (making it Type-D) introduces a challenge.

Now obviously I can work around some of these problems by using compiler defines (thus keeping source files the same in both branches), editing code manually and manually removing files after merges but this doesn’t feel like the most efficient and clean way to handle this.

Surely this is a common enough work flow that wiser people than me already figured out. Can anyone suggest any method or best practices that can streamline the work in these scenarios? Or is there something fundamentally flawed with my setup?

Also, does Git handles these flows more gracefully?

Thanks.

Answer 1

I would do any development that a the customer requires on the customer branch and merge it into default. This will work for hotfixes and it is simpler than cherry-picking your development changesets from your default branch. It’s easier to merge forwards rather than backwards. It also gets rid of Type-B file problem because there are no Type-B files in the customer branch.

Type C files I would merge into default and then delete on the default branch. Any further modifications to these files should generate a warning that file modified on branch was deleted on the other branch.