Understanding and resolving merge conflicts – Donny Wals

Git is nice, and when it really works effectively it may be a breeze to work with. You push , pull, commit, department, merge, however then… you get right into a merge battle, On this submit, we’ll discover merge conflicts. We’ll take a look at why they occur, and what we are able to do to keep away from operating into merge conflicts within the first place.

Let’s begin by understanding why a merge battle occurs.

Understanding why a merge battle occurs

Git is often fairly good at merging collectively branches or commits. So why does it get confused typically? And what does it imply when a merge battle happens?

Let me begin by saying {that a} merge battle shouldn’t be your fault. There’s a superb likelihood that you just couldn’t have averted it, and it’s most actually not one thing you must really feel unhealthy about.

Merge conflicts occur on a regular basis and they’re all the time fixable.

The explanation merge conflicts occur is that git typically will get conflicting details about modifications. For instance, possibly your coworker break up an enormous Swift file into two or extra recordsdata. You’ve made modifications to components of the code that was now moved into an extension.

The next two code snippets illustrate the earlier than state of affairs, and two “after” conditions.

// Earlier than
struct MainView: View {
  var physique: some View {
    VStack {
      Textual content("That is an instance")

      Button("Counter ++") {
        // ...
      }
    }
    .padding(16)
  }
}

// After on department foremost
struct MainView: View {
  var physique: some View {
    VStack {
      Textual content("That is one other instance")
      Textual content("It has a number of strains!")

      Button("Counter ++") {
        // ...
      }
    }
    .padding(16)
  }
}

// After on characteristic department
struct MainView: View {
  var physique: some View {
    VStack {
      MyTextView()

      CounterButton()
    }
    .padding(16)
  }
}

When git tries to merge this, it will get confused.

Programmer A has deleted some strains, changing them with new views whereas programmer B has made modifications to these strains. Git wants some help to inform it what the suitable strategy to merge that is. A merge battle like that is no person’s fault as a result of it’s completely affordable for one developer to be refactoring code and for one more developer to be engaged on part of that code.

Normally you’ll attempt to keep away from two builders engaged on the identical recordsdata in a brief timespan, however on the similar time git makes it in order that we can work on the identical file on a number of branches so it’s not widespread for builders to synchronize who works on which recordsdata and when. Doing so can be an enormous waste of time, so we as a substitute we depend on git to get our merges proper most often.

Each time git sees two conflicting modifications on the identical a part of a file, it asks a human for assist. So let’s transfer on to seeing totally different approaches to resolving merge conflicts.

Resolving merge conflicts

There’s no silver bullet for resolving your merge conflicts. Sometimes you’ll select one among three choices while you’re resolving a battle:

• Resolve utilizing the incoming change (theirs)
• Resolve utilizing the present change (mine)
• Resolve manually

In my expertise you’ll often need to use a guide decision when fixing merge conflicts. Earlier than I clarify how that works, let’s take a Fast Take a look at how resolving utilizing “mine” and “theirs” works.

A merge conflicts all the time occurs while you attempt to apply modifications from one commit onto one other commit. Or, while you attempt to merge one department into one other department.

Generally git can merge components of a file whereas different components of the file trigger conflicts. For instance, if my commit modifications line 2 of a selected file, and the opposite commit removes that line. My commit additionally provides a couple of strains of code on the finish of the file, and the opposite commit doesn’t.

Git can be good sufficient to append the brand new strains to the file, however it could’t determine what to do with line 2 of the recordsdata since each commits have made modifications in a approach that git can’t merge.

On this case, we are able to make a option to both resolve the battle for line 2 utilizing my commit (make a change to line 2) or utilizing the opposite commit (delete the road altogether).

Deciding what must be achieved can typically require some work and collaboration.

In case your coworker deleted a selected line, it’s value asking why they did that. Possibly line 2 declares a variable that’s now not wanted or used so your coworker figured they’d delete it. Possibly you didn’t verify whether or not the variable was nonetheless wanted however you utilized a formatting change to eliminate a SwiftLint warning.

In a state of affairs like this, it’s secure to resolve your battle utilizing “their” change. The road might be eliminated so you’ll be able to inform git that the incoming change is what you need.

In different conditions issues may not be as easy and also you’ll have to do a guide merge.

For instance, let’s say that you just break up a big file into a number of recordsdata whereas your coworker made some modifications to one of many capabilities that you just’ve now moved into a special file.

If that is so, you’ll be able to’t inform git to make use of one of many commits. As an alternative, you’ll have to manually copy your coworker’s modifications into your new file in order that all the things nonetheless works as meant. A guide battle decision can typically be comparatively easy and fast to use. Nonetheless, they may also be fairly complicated.

If you happen to’re not 100% certain about one of the simplest ways to resolve a battle I extremely suggest that you just ask for a second pair of eyes that can assist you out. Ideally the eyes of the writer of the conflicting commit as a result of that may assist be sure to don’t by accident discard something your coworker did.

Throughout a merge battle your undertaking received’t construct which makes testing your battle decision nearly inconceivable. When you’ve resolved all the things, be sure to compile and take a look at your app earlier than you commit the battle decision. If issues don’t work and you haven’t any thought what you’ve missed it may be helpful to only rewind and take a look at once more by aborting your merge. You an do that utilizing the next command:

git merge --abort

It will reset you again to the place you have been earlier than you tried to merge.

If you happen to method your merge conflicts with warning and also you pay shut consideration to what you’re doing you’ll discover that almost all merge conflicts might be resolved with out an excessive amount of bother.

Merge conflicts might be particularly tedious while you attempt to merge branches by rebasing. Within the subsequent part we’ll check out why that’s the case.

Resolving conflicts whereas rebasing

If you’re rebasing your department on a brand new commit (or department), you’re replaying each commit in your department utilizing a brand new commit as the place to begin.

This may typically result in fascinating issues throughout a rebase the place it feels such as you’re resolving the identical merge conflicts again and again.

In actuality, your conflicts can preserve popping up as a result of every commit can have its personal incompatibilities together with your new base commit.

For instance, take into account the next diagram as our git historical past:

You possibly can see that our foremost department has obtained some commits since we’ve created our characteristic department. Because the foremost department has modified, we need to rebase our characteristic department on foremost in order that we all know that our characteristic department is totally updated.

As an alternative of utilizing a daily merge (which might create a merge commit on characteristic) we select to rebase characteristic on foremost to make our git historical past look as follows:

We run git rebase foremost from the command line and git tells us that there’s a battle in a selected file.

Think about that this file appeared like this after we first created characteristic:

struct MainView: View {
  var physique: some View {
    VStack {
      Textual content("That is an instance")

      Button("Counter ++") {
        // ...
      }
    }
    .padding(16)
  }
}

Then, foremost obtained some new code to make the file appear to be this:

struct MainView: View {
  var physique: some View {
    VStack {
      Textual content("That is one other instance")
      Textual content("It has a number of strains!")

      Button("Counter ++") {
        // ...
      }
    }
    .padding(16)
  }
}

However our characteristic department has a model of this file that appears as follows:

struct MainView: View {
  var physique: some View {
    VStack {
      MyTextView()

      CounterButton()
    }
    .padding(16)
  }
}

We didn’t get to this model of the file on characteristic in a single step. We even have a number of commits that made modifications to this file so after we replay our commits from characteristic on the present model of foremost, every particular person commit may need a number of conflicts with the “earlier” commit.

Let’s take this step-by-step. The primary commit that has a battle seems to be like this on characteristic:

struct MainView: View {
  var physique: some View {
    VStack {
      MyTextView()

      Button("Counter ++") {
        // ...
      }
    }
    .padding(16)
  }
}

struct MyTextView: View {
  var physique: some View {
    Textual content("That is an instance")
  }
}

I’m certain you’ll be able to think about why this can be a battle. The characteristic department has moved Textual content to a brand new view whereas foremost has modified the textual content that’s handed to the Textual content view.

We are able to resolve this battle by grabbing the up to date textual content from foremost, including it to the brand new MyTextView and proceed with our rebase.

Now, the subsequent commit that modified this file may even have a battle to resolve. This time, we have to inform git get from our beforehand mounted decide to this new one. The explanation that is complicated git is that the commit we’re making an attempt to use can now not be utilized in the identical approach that it was earlier than; the bottom for each commit in characteristic has modified so every commit must be rewritten.

We have to resolve this battle in our code editor, after which we are able to proceed the rebase by operating git add . adopted by git rebase --continue. It will open your terminal’s textual content editor (usually vim) permitting you to vary your commit message if wanted. If you’re proud of the commit message you’ll be able to end your commit by hitting esc after which writing :wq to jot down your modifications to the commit message.

After that the rebase will proceed and the battle decision course of must be repeated for each commit with a battle to guarantee that every commit builds appropriately on prime of the commit that got here earlier than it.

If you’re coping with a handful of commits that is positive. Nonetheless when you’re resolving conflicts for a dozen of commits this course of might be irritating. If that’s the case, you’ll be able to both select to do a merge as a substitute (and resolve all battle directly) or to squash (components of) your characteristic department. Squashing commits utilizing rebase is a subject that’s fairly superior and could possibly be defined in a weblog submit of its personal. So for now, we’ll skip that.

If you’ve determined the way you need to proceed, you’ll be able to abandon your rebase by operating git rebase --abort in your terminal to return to the state your department was in earlier than you tried to rebase. After that, you’ll be able to resolve to both do a git merge as a substitute, or you’ll be able to proceed with squashing commits to make your life somewhat bit simpler.

Git rebase and your distant server

If you happen to’ve resolved all of your conflicts utilizing rebasing, you’ve barely altered all the commits that have been in your characteristic department. If you happen to’ve pushed this department to a distant git server, git will inform you that your native repository has n commits that aren’t but on the distant, and that the distant has a (often) equal variety of commits that you don’t but have.

If the distant has extra commits than you do, that’s an issue. It is best to have pulled first earlier than you probably did your rebase.

The explanation it is advisable pull first in that state of affairs is since you want to have the ability to rebase all commits on the department earlier than you push the rewritten commits to git since with the intention to do a push like that, we have to inform git that the commits we’re pushing are appropriate, and the commits it had remotely ought to be ignored.

We do that by passing the --force flag to our git push command. So for instance git push --force characteristic.

Word that you must all the time be tremendous cautious when pressure pushing. It is best to solely ever do that after a rebase, and when you’re completely certain that you just’re not by accident discarding commits from the distant by doing this.

Moreover, when you’re engaged on a department with a number of folks a pressure push might be fairly irritating and problematic to the native branches of your coworkers.

As a normal rule, I attempt to solely rebase and pressure push on branches that I’m engaged on on my own. As quickly as a department is being labored on my others I swap to utilizing git merge, or I solely rebase after checking in with my coworkers to guarantee that a pressure push is not going to trigger issues for them.

When doubtful, all the time merge. It’s not the cleanest resolution because of the merge commits it creates, however no less than you already know it received’t trigger points to your teammates.

In Abstract

Merging branching is a daily a part of your everyday work in git. Whether or not it’s since you’re tying to soak up modifications somebody made right into a department of your individual or it’s since you need to get your individual modifications in to your foremost department, understanding totally different merging methods is vital.

No matter how you propose to merge branches, there’s a risk to run right into a merge battle. On this submit, you’ve discovered why merge conflicts can occur, and how one can resolve them.

You’ve additionally study why rebases can run into a number of merge conflicts and why you must all the time resolve these conflicts one after the other. Briefly, it’s as a result of git replays every commit in your department on prime of the “present” commit for the department you’re rebasing on.

The important thing to resolving conflicts is all the time to maintain your cool, take it straightforward, and work via the conflicts one after the other. And when doubtful it’s all the time a good suggestion to ask a coworker to be your second pair of eyes.

You additionally discovered about pressure pushing after rebasing and the way that may be problematic when you’re working in your department with a number of folks.

Do you’ve any methods you like to make use of whereas resolving conflicts? Let me know on X or Threads!