Awesome

Git Interactive Rebase Tool

Native cross-platform full-featured terminal-based sequence editor for interactive rebase in Git 1.7.8+.

Table of Contents

• Features
• Install
• Setup
• Usage
• Customization
• Development
• Related Projects
• License

Features

Cross-platform

Built and works on Linux, macOS, Windows, and many others.

Set action

Easily set the action to pick, squash, fixup, edit, reword and drop.

Reorder rebase list

Reorder the action list with a single key press.

Multiline modification

Change action and reorder multiple lines at once with visual mode.

Toggle breaks

View commit details and diff

View the commit overview, and a full commit diff with a press of a key.

Unicode and Emoji support

Edit exec command

Easily edit the command that is run by an exec command.

Edit in external editor

Need to do something in your Git editor? Quickly shell out to your editor, make a change and return to the tool.

Advanced Features

Modified line exec command

This optional feature allows for the injection of an exec action after modified lines, where modified is determined as a changed action, command, or reference. This can be used to amend commits to update references in the commit message or run a test suite only on modified commits.

To enable this option, set the interactive-rebase-tool.postModifiedLineExecCommand option, providing an executable or script.

git config --global interactive-rebase-tool.postModifiedLineExecCommand "/path/to/global/script"

Or using repository-specific configuration, for targeted scripts.

git config --global interactive-rebase-tool.postModifiedLineExecCommand "/path/to/repo/script"

The first argument provided to the script will always be the action performed. Then, depending on the action, the script will be provided a different set of arguments.

For drop, fixup, edit, pick, reword and squash actions, the script will additionally receive the original commit hash, for exec the original and new commands are provided, and for label, reset, merge, and update-ref the original label/reference and new label/reference are provided.

Full example of a resulting rebase todo file, assuming that interactive-rebase-tool.postModifiedLineExecCommand was set to script.sh.

# original line: label onto
label new-onto
exec script.sh "label" "onto" "new-onto"

# original line: reset onto
reset new-onto
exec script.sh "reset" "onto" "new-onto"

pick   a12345 My feature
# original line: pick b12345 My change
squash b12345 My change
exec script.sh "squash" "b12345"

# original line: label branch
label branch
exec script.sh "label" "branch" "new-branch"

# original line: exec command
exec new-command
exec script.sh "exec" "command" "new-command"

Setup

Most systems

git config --global sequence.editor interactive-rebase-tool

Windows

Standard Command Prompt and Windows Terminal

git config --global sequence.editor "'C:/path/to/interactive-rebase-tool.exe'"

Git Bash

Git Bash requires the use of winpty in order to work correctly, so to set the editor use:

git config --global sequence.editor "winpty /c/path/to/interactive-rebase-tool.exe"

Notes

Windows before version 10 has serious rendering issues with saturated darker colors, such as the blue color that is entirely illegible on modern displays. While it is possible to avoid using saturated colors, a better option is to update the theme using Microsoft's ColorTool.

Temporary Override

You can temporarily use a different sequence editor by using the GIT_SEQUENCE_EDITOR environment variable:

GIT_SEQUENCE_EDITOR=emacs git rebase -i [<upstream> [<branch>]]

Direct Usage

interactive-rebase-tool <rebase-todo-filepath>
interactive-rebase-tool --help
interactive-rebase-tool --version

Getting Help

The tool has built-in help that can be accessed by using the ? key.

Common Default Key Bindings

Key bindings can be customized, see configuration for all key bindings and information on configuring.

Supported Platforms

Linux

Supported on all Linux based distributions. The project is tested on Debian and Ubuntu, but should work on any standard Linux distribution. If the project is not working on your platform, please open an issue.

The tool is tested in Tilix and Gnome Terminal.

macOS

Supported on the latest version of macOS, though previous versions should work.

The tool is tested in iTerm2 and Terminal.

Windows

Supported on the latest versions of Windows 10 and Windows 11.

The tool is tested on Windows 11 in PowerShell and Command Prompt inside Windows Console and Windows Terminal. The latest version of Git Bash provided from Git for Windows is also supported.

Windows Console and Git Bash are only minimally supported, and some features or graphical glitches may occur. Windows Console running in legacy mode is not supported.

Cygwin is not officially supported.

Others

Other platforms are not officially supported. Some platforms have community support, and if you are having trouble getting the project working on your platform, please open an issue.

Development

Install Rust

To start developing the project, you will need to install Rust, which can generally be done using rustup.

Setup

Cargo Make

This project uses cargo-make as a task runner. To install:

cargo install --force cargo-make

Debian and derivatives

If you plan to build a release package you will need pkg-config and liblzma-dev. They can be installed using apt:

sudo apt install pkg-config liblzma-dev

Build and run

To build or run the project, from the project root run:

# only build
cargo make build --release
# build and run
cargo run -- <path-to-git-rebase-todo-file>

Sample rebase todo files can be found in ./test/fixtures.

Tests

Automated tests are available for all features and can be run with:

cargo make test

Docs

API docs for the project are generated using Rust Doc:

cargo make docs

Linting

An addition to the lints provided by rustc, this project uses Clippy to provide additional linting, run with:

cargo make lint

This will run lints using stable and nightly. The nightly lints may show errors, but will not result in a failure.

Format

This project uses rust-fmt to provide a consistent format. A helpful script will ensure that all files are formatted correctly:

cargo make format

Coverage

The project use Tarpaulin to generate coverage reports. Coverage reports are used to find gaps in tests. To generate the coverage report:

cargo make coverage

An addition to the report printed to the CLI, an HTML report can be found in the coverage directory.

Release

Debian Packaging Building

cargo make build-deb

A deb file will be written to target/debian/git-interactive-rebase-tool_*.deb.

RPM Building

cargo make build-rpm

A rpm file will be written to target/generate-rpm/git-interactive-rebase-tool-*.deb.

Reproducible Builds

Providing a SOURCE_DATE_EPOCH environment variable with a valid Unix timestamp, defined in seconds, will ensure a reproducible build.

Related Projects

• rebase-editor is a very similar project written in Node.js.
• cj-git-patchtool is another tool for doing git rebase en masse.
• andrewshadura/git-crecord provides interactive selection of changes to a commit.

License

Copyright © 2017-2024 Tim Oram and Contributors

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

A copy of the GNU General Public License can be found in the file COPYING.

See Third Party Licenses for licenses of the third-party libraries used by this project.