Merging Strategies in Git: Resolving Conflicts by Favoring Another Branch's Changes

Introduction

When working with Git, merging branches is a common task that often results in conflicts. Developers need tools to efficiently resolve these conflicts and decide which changes should take precedence. In scenarios where you want all conflicting files from one branch (say branchB) to overwrite those in another branch (branchA), using strategies like -s ours or -X theirs can be beneficial. This tutorial explores various methods for achieving this, focusing on the "theirs" strategy.

Understanding Merge Strategies

Git provides several merge strategies that determine how conflicts are resolved during a merge:

• Recursive: The default strategy that tries to auto-merge changes but falls back to manual conflict resolution when necessary.
• Ours: This strategy results in a merged tree containing only the content from the current branch, ignoring the other branch entirely.

While Git does not natively support a "theirs" strategy like git merge -s theirs, several workarounds can achieve similar outcomes.

Method 1: Using Strategy Option -X theirs

One common method is to use the --strategy-option (or -X) with recursive merges:

git checkout branchA
git merge -X theirs branchB

This approach resolves conflicts by favoring changes from branchB. However, it performs a full recursive merge and may handle deleted files differently than expected. If a file is deleted in branchB, you might need to manually remove it with:

git rm {DELETED-FILE-NAME}

Method 2: Manual Merge Resolution

Another approach involves manually resolving conflicts by checking out the necessary changes from branchB after an initial merge. This method ensures that all files are resolved as if they originated solely from branchB.

1. Merge with -s ours:

   git checkout branchA
   git merge -s ours branchB
   

2. Create a Temporary Branch:

   git branch branchTEMP
   

3. Reset to branchB Content:

   git reset --hard branchB
   

4. Soft Reset Back to the Merge Commit:

   git reset --soft branchTEMP
   

5. Amend the Merge Commit:

   git commit --amend
   

6. Cleanup Temporary Branch:

   git branch -D branchTEMP
   

This sequence effectively amends the merge commit to reflect only branchB‘s changes while maintaining correct parentage.

Method 3: Interactive Conflict Resolution

For those preferring interactive resolution, you can perform a standard merge and manually resolve each conflict:

1. Merge with Recursive Strategy:

   git checkout branchA
   git merge branchB
   

2. Resolve Conflicts Using --theirs:

   For each file in conflict:

   git checkout --theirs <file>
   

This method gives you fine-grained control over individual files, allowing specific adjustments as needed.

Conclusion

While Git does not natively support a -s theirs strategy, the above methods provide effective alternatives. Each has its use cases: -X theirs is quick for straightforward scenarios; manual resolution offers more precision and control; interactive conflict handling allows granular file-by-file management. Understanding these techniques enhances your ability to manage complex merges efficiently.

Best Practices

• Always ensure that you have a backup of your work before performing operations that alter commit history.
• Consider the impact on shared repositories when rewriting merge commits.
• Use meaningful branch names and commit messages to maintain clarity in collaborative environments.

By mastering these strategies, developers can handle branch merges with confidence, ensuring their projects remain stable and up-to-date.