Package guilt

Scripts to manage quilt-like patches on top of git

http://www.kernel.org/pub/linux/kernel/people/jsipek/guilt/

Guilt allows one to use quilt functionality on top of a Git repository.
Changes are maintained as patches which are committed into Git. Commits can
be removed or reordered, and the underlying patch can be refreshed based on
changes made in the working directory. The patch directory can also be
placed under revision control, so you can have a separate history of changes
made to your patches.

General Commands (Section 1)
guilt-add
Adds the files specified to git using git-add(1) making it available to guilt.
guilt-applied
Prints a list of all applied patches.
guilt-branch
Create a copy of the entire branch patch directory (.git/patches/<branch>) to (.git/patches/<new_name>), create a new git branch <new_name> and check it out.
guilt-commit
guilt commit -n <num> | -a | --all Turn specified number of bottom most patches into Git commits. This removes the the patches from the series, and status file.
guilt-delete
Delete an unapplied patch from the series.
guilt-diff
Outputs top-most applied diff and any additional changes in the working directory to standard output.
guilt-export
Export a guilt series to be used by quilt.
guilt-files
Print the list of files that the topmost patch changes.
guilt-fold
guilt fold [-k] <patchname>
guilt-fork
Create a copy of the top most patch, and replace the entry in the series file to use this new patch file.
guilt-graph
Create a dot(1) directed graph showing the dependencies between applied patches.
guilt-guard
Assign guards to the specified patch, or to the patch on top of the stack if no patch is given on the command line. An unguarded patch is always pushed. A...
guilt-header
Prints either the topmost patch’s header or the header of a specified patch. -e
guilt-help
Open up the man page for a guilt command.
guilt-import
Import a specified patch file into the series, placing it after the current topmost patch.
guilt-import-commit
Import one or more commits as individual patches.
guilt-init
Initialize a git repository for use with guilt
guilt-new
Create a new patch and push it on top of the stack. An optional patch description can be supplied either interactively on via the command line.
guilt-next
Output the name of next patch to be pushed. If guilt-push(1) is issued, this patch would be the topmost patch.
guilt-patchbomb
Send a series of commits via email asking for To, CC and other information interactively.
guilt-pop
guilt pop [-f] [-a | --all | -n <num> | <patchname>]
guilt-prev
Output name of second topmost applied patch. If guilt-pop(1) is used, this patch will become the topmost patch.
guilt-push
guilt push [ -f ] [-a | --all | -n <num> | <patchname>]
guilt-rebase
Rebase pushed patches against an upstream branch.
guilt-refresh
Refresh topmost applied patch with changes in the working copy.
guilt-repair
Perform various repository repairs. You must specify one mode of repair: --full
guilt-rm
Removes the files specified from git using git-rm(1).
guilt-select
Select guards to apply when pushing patches. Guards are selected without the + or - prefix.
guilt-series
Print the stack of patches on this branch.
guilt-status
Each file is printed with a prefix that describes it’s status.
guilt-top
Output name of topmost applied patch
guilt-unapplied
List all unapplied patches.
Miscellanea (Section 7)
guilt
Andrew Morton originally developed a set of scripts for maintaining kernel patches outside of any SCM tool. Others extended these into a suite called quilt. The...