Git Patches: Your friend to less Copy-Paste
Tags: git, programming, tutorial, beginners
Published: 2023-09-24 21:40:56

Git, the most widely used version control system, offers a powerful feature called **patches**. 
Patches allow developers to share and apply changes between different repositories or branches. 

As part of a project I am working on, I found myself relying on this functionality and have explored a couple features. In this post, we will explore the world of Git patches, discussing their benefits and demonstrating how to utilize them effectively. We will cover relevant commands, provide code examples, and delve into the advantages of using rejection (rej) files and hunks.

## Table of Contents

1. What are Git Patches?
2. Creating Patches
   - `git format-patch`
   - Example: Creating a Patch
3. Applying Patches
   - `git apply`
   - Example: Applying a Patch
4. Using Rej Files
   - Understanding Rej Files
   - Resolving Conflicts with Rej Files
5. Working with Hunks
   - Understanding Hunks
   - Manipulating Hunks
6. Wrap up

## 1. What are Git Patches?

Git patches are a way to capture and transfer changes made to a codebase. A patch file contains a textual representation of the differences between two states of a repository. It includes information about added, modified, or deleted lines in the code.

Patches are valuable for sharing changes with others or applying them to different branches or repositories. They enable efficient code collaboration, particularly when dealing with remote teams or contributors.

## 2. Creating Patches

Git provides the `git format-patch` command to generate patches from commits or branches. Let's see how it works. I've made a repo as demo for this post which has the following commits.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1oqc46f43s054gzbehe0.png)

### `git format-patch` Command

The `git format-patch` command creates patch files for each commit in a specified range or branch. It generates files in the ".patch" format, which can be easily shared and applied.

### Example: Creating a Patch

To create a patch for a specific commit, use the following command:

```
git format-patch <commit>
```

For instance, to generate a patch for the last three commits, execute:

```
git format-patch HEAD~2
```

This command will produce two patch files, each representing a commit.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yg955dcpk3wl4vq5u6bh.png)

## 3. Applying Patches

Once patches are created, they can be applied to a repository using the `git apply` command. Applying patches allows for seamless integration of changes into a codebase.

### `git apply` Command

The `git apply` command is used to apply patches to a repository. It takes patch files and modifies the code accordingly.

### Example: Applying a Patch

To apply a patch file, use the following command:

```
git apply <patch-file>
```

For example, to apply a patch named "this-is-my-patch.patch," run:

```
git apply this-is-my-patch.patch
```

The changes described in the patch file will be applied to the working directory.

A patch file contains something similar to a `diff` of the file and where the changes have occurred. The following is a sample of one of the patch files used for this demo.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mxb715vojr8ox6pml6u2.png)

## 4. Using Rej Files

If there's a mismatch between the file that you want to apply the patch to and the patch files, you will see a message similar to this.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2hchsuuivvckccd84n73.png)

To over come this, we can utilize `rej` files.

Rej files (rejection files) are generated during the patch application process when conflicts occur. They provide valuable information about rejected changes and aid in resolving conflicts effectively.

These are produced when the `git apply` command is used in a similar fashion:

```bash
git apply --reject --whitespace=fix this-is-my-patch.patch
```


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gn5zhgaivalrzk8rn8px.png)

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gexbhmt3rvtk3szntfgo.png)

### Understanding Rej Files

When Git encounters conflicts while applying a patch, it creates a rej file for each conflicting hunk. A rej file highlights the conflicting lines and provides context for resolving the conflicts.

### Resolving Conflicts with Rej Files

To resolve conflicts using rej files, follow these steps:

1. Open the rej file in a text editor.
2. Identify the conflicting lines and understand the context.
3. Manually modify the code to resolve the conflicts.
4. Use the `git apply --reject` command to reapply the patch, taking into account the manual modifications made.

Using rej files streamlines the conflict resolution process, ensuring accurate application of changes.

## 5. Working with Hunks

Hunks are portions of a patch file that describe a specific set of changes. Understanding and manipulating hunks allow for fine-grained control over patch application.

### Understanding Hunks

Hunks represent the isolated changes within a patch file. They contain information about the lines affected, whether they were added, modified, or deleted, and context lines surrounding the changes.

### Manipulating Hunks

To manipulate hunks during patch application, consider the following:

- To apply only specific hunks from a patch file, use the `--include` or `--exclude` options with the `git apply` command.
- To interactively choose individual hunks to apply, utilize the `git add --patch` command.

Manipulating hunks provides flexibility in applying changes, allowing for precise control over the patches.

## 6. Wrap up

Git patches are an indispensable tool for code collaboration and efficient transfer of changes between repositories. By understanding how to create and apply patches, utilize rej files, and work with hunks, developers can enhance their collaboration and streamline the integration of code.

Leveraging Git patches allows developers to easily share their changes, collaborate effectively with remote teams, and ensure seamless integration of code across branches and repositories. Understanding the commands and techniques associated with Git patches empowers developers to optimize their workflow and enhance productivity.

GL HF