How to merge a local branch to main

Background

Merging a local dev branch directly into main without creating a pull request might not be the standard practice in team-based or open-source projects. However, there are scenarios where this can make sense. Here are five reasons:

1. Extremely large merges: Often when migrating repositories, users will want to merge development branches into the main branch. Due to the large size, you may want to merge locally. This can benefit file transfer, as well as avoid server timeouts.

2. Simple Projects & Solo Development: If someone is working on a personal project or a simple project where they are the only developer, there might not be a need for the formal process of a pull request. Directly merging the dev branch into main can streamline the development process.

3. Rapid Iteration & Testing: In situations where rapid changes are necessary, such as bug fixes during a live event or during an urgent production issue, one might choose to merge changes directly to expedite the process, though this comes with its risks.

4. Internal or Temporary Branches: Sometimes developers create branches not for features or bug fixes but for experimental changes, trying out new ideas, or other internal purposes. When these changes are deemed stable and it's time to integrate them, the developer might choose to merge them directly, especially if these branches weren't pushed to a remote repository.

5. Limited or No Network Access: If a developer is working in an environment with limited or no internet access and cannot easily push their branch and create a pull request through a remote platform (like GitHub or GitLab), they might choose to merge branches locally. Once network access is available again, they can push the updated main branch.

That said, for collaborative projects, especially with multiple team members, design reviews (pull requests) provide an opportunity for code review, discussion, and testing before changes are merged into the main branch. This process is valuable for ensuring code quality and project stability.

Merging a local branch to main

1. Check your current branch
Before making any changes, always verify which branch you're on:

git branch

2. Make sure your local branches are up to date
Fetch any updates from the remote repository:

git fetch origin

3. Switch to the branch you want to merge into
Since you want to merge into the main branch, you first need to switch to it:

git checkout main

4. Update the main branch
It's good practice to make sure your main branch has the latest updates from the remote repository:

git pull origin main

5. Merge the dev branch into main
Now you can merge the dev branch into main:

git merge dev

If there are no merge conflicts, the branches will be merged successfully.

6. If you encounter merge conflicts
Should there be any conflicts between the branches, Git will notify you. You'll then need to resolve these conflicts manually by editing the conflicting files. Look for lines marked with <<<<<<<, =======, and >>>>>>> to identify and resolve differences.

After resolving conflicts, mark the files as resolved with:

git add <filename>

Then, continue with the merge by committing the changes:

git commit

7. Push the updated main branch to the remote repository
Now that your local main branch has been updated, you'll want to reflect these changes in the remote repository:

git push origin main

8. (Optional) Clean up
If you're done with the dev branch and it's been merged successfully, you might consider deleting it locally and/or on the remote:

Delete locally:

git branch -d dev

Delete on the remote (be careful with this step, ensure that the branch is no longer needed):

git push origin --delete dev

That's it! Your dev branch has now been merged into the main branch.