Testing versions of code with shared portions

your main question: How can you handle updates to shared code during merges without impacting branch-specific code?

1. Store shared code in a directory and keep branch specific code in separate directories for each branch.

2. Use git merge to incorporate changes from the shared code into different branches.

3. After each merge, thoroughly test the code to ensure that the shared code is updated correctly, while branch-specific code remains unchanged.

good luck mate, Hopefully, this will guide you in the right direction

I want to have branch-specific code that is not affected when I merge

There are 2 general ways to accomplish this:

1. Use a custom merge script which "knows" which files and/or parts of files should be ignored. (Tip: ignoring complete files is easier than ignoring portions of files.) The idea here is that the script starts the merge with: git merge --no-commit. Then it undoes changes to certain files (or portions of files), then it completes the merge. The downside of this is you must know what all of the stuff to ignore is in advance.
2. Use n+1 branches. In your case, if you have two branches with stuff on it, say branch1 and branch2, then you need a third branch with all the common code, say, main. Make common changes to main, and then merge main into both branch1 and branch2 when you're ready to take those changes. Then, only put branch1 specific code in branch1, and similarly only put branch2 specific code in branch2, and never merge branch1 into branch2, or vice versa.

Do the work in your work tree, record it where it belongs. Git is made for this.

Here's the basic sketch

git checkout branch1
work work work making common and branch1 changes but not adding anything yet
git commit -p                  # pick only the branch1-specific changes
git checkout -m common         # now carry any remaining changes over to the common tip
git commit -a                  # add and commit those
git checkout branch2           # then merge them in to the branch2 tip
git merge common               # ...

and if your tip-specific changes are in separate files you can skip the patch selection with git commit -o instead of git commit -p.

You’re asking about a Git workflow where you want to merge common code changes while keeping the branch-specific code intact. Here’s a process you can follow to achieve that:

1. Use git merge for the common code

When you are working on a feature in branch 1, and you want to modify common code, follow these steps:

1. Make the common code change in branch 1.
2. Commit the change to branch 1.
3. When you switch to branch 2, you can use git merge branch1 to pull the common code changes into branch 2.

Git will automatically merge the common code. However, it won’t touch the specific code in branch 2 because it has different changes.

2. Prevent automatic merging of specific code

To prevent Git from automatically merging the specific code and instead raise a conflict or leave it unchanged:

1. Use git merge with -X ours or -X theirs to prefer one branch's changes.

   • git merge branch1 -X ours: This keeps your changes in branch 2 and ignores the changes from branch 1 for specific code.
   • git merge branch1 -X theirs: This does the opposite, where the changes from branch 1 are preferred for the specific code in branch 2.

   If you do a regular git merge, Git will try to merge everything, including the branch-specific code. But with -X ours or -X theirs, you’re telling Git to prioritize one side for specific code.

3. Use Git's Conflict Resolution Process

If you want a conflict to be raised for the specific code, you can manually edit the code to introduce a conflict before merging. For example, in branch 2, you can temporarily modify the specific code in a way that will cause a conflict when merged, and Git will then prompt you to resolve it.

Alternatively, if you're working with rebase instead of merge:

1. Rebase your changes onto the other branch, and Git will preserve changes in branch 2 but still bring in the common code changes.
2. During rebase, if there’s a conflict, Git will stop and let you resolve it.

4. Branch-Specific Code in Separate Files/Methods

If feasible, consider isolating branch-specific code into separate files or methods that won’t overlap with the common code. That way, merging becomes easier because there’s a clearer distinction between the common code and the branch-specific code.

Example Workflow:

1. Make your changes in branch 1.
2. Commit those changes.
3. Switch to branch 2 and merge branch1 with a strategy (-X theirs, -X ours), or manually resolve the conflict if you want to be more explicit.
4. Test the result and push.

That’s a clean way to ensure that common code merges while keeping branch-specific code intact.

Let me know if you need more clarification!