Provided by: guilt_0.30-1_all bug

NAME

       guilt - quilt on top of git

SYNOPSIS

       guilt COMMAND [ARGS]

DESCRIPTION

       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 basic idea behind quilt is to maintain patches
       instead of maintaining source files. Patches can be added, removed or
       reordered, and they can be refreshed as you fix bugs or update to a new
       base revision. quilt is very powerful, but it is not integrated with
       the underlying SCM tools. This makes it difficult to visualize your
       changes.

       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.

PATCHES DIRECTORY

       In Guilt, all the patches are stored in .git/patches/$branch/, where
       $branch is the name of the branch being worked on. This means that one
       can have a independent series of patches for each branch present in the
       repository. Each of these per-branch directories contains 2 special
       files:

       series: This file contains a list of all the patch filenames relative
       to the per-branch patch directory. Empty and commented out lines are
       ignored.

       status: This file contains the state of the stack. What patches are
       applied.

HOOKS

       Any guilt operation may execute zero or more hook scripts which can be
       used to run any houskeeping commands or even abort the execution of the
       command.

HOOKS DIRECTORY

       Guilt follows the same basic design of hooks in Git itself. All Guilt
       hooks are executable files (generally shell scripts, but they can be
       anything the operating system can execute) in .git/hooks/guilt/.

       The following hooks are supported:

       delete <patch name>
           Executed when a patch is deleted from the patch series via
           guilt1[1].

AUTOTAGGING

       Autotagging is a feature that automatically creates unannotated tags
       for top, bottom, and base of the stack.

       On every push or pop operation (refresh is a pop followed by a push),
       Guilt

           Top: Top-most applied patch/commit
           Bottom: Bottom-most applied patch/commit
           Base: Commit on top of which the bottom most patch is applied
       Having these three tags, one can easily get the log/diff/other
       information only for commits that are (or are not!) part of the patch
       stack.

       Since some users may not want to have Guilt autotag, a Git config
       setting guilt.autotag can be used to turn it on or off.

           If none of the config files (system, global, etc.) contain a
           guilt.autotag, the feature defaults to being on.

           If one or more config file contains the value, regular
           git-config(1) rules apply.
       During guilt-init(1), the rules are:

           If none of the config files contain guilt.autotag, the repository
           config file´s guilt.autotag is set to the default (on).

           If there already exists a setting in any of the config files, and
           neither of the autotagging related options is used, no local value
           is set.

           If there already exists a setting in any of the config files, but
           an autotagging option is specified, the repository config file´s
           guilt.autotag is set to the value specified on the command line.

GUILT COMMANDS

       All commands can be called with or without a dash. e.g. guilt add or
       guilt-add

       guilt1[2]
           guilt-add - Add a file to git and guilt.

       guilt1[3]
           guilt-applied - List applied patches.

       guilt1[4]
           guilt-branch - Branch the entire patch series.

       guilt1[5]
           guilt-commit - Commit specified number of patches.

       guilt1[1]
           guilt-delete - Delete a patch.

       guilt1[6]
           guilt-diff - Outputs various diffs.

       guilt1[7]
           guilt-export - Export a patch series (to be used by quilt).

       guilt1[8]
           guilt-files - Print the list of files that the topmost patch
           changes.

       guilt1[9]
           guilt-fold - Fold a specified patch into the topmost applied patch.

       guilt1[10]
           guilt-fork - Fork the topmost applied patch.

       guilt1[11]
           guilt-graph - Create a patch dependency graph.

       guilt1[12]
           guilt-header - Print a patch header.

       guilt1[13]
           guilt-help - open man page of a guilt command.

       guilt1[14]
           guilt-import-commit - Import one or more commits as patches.

       guilt1[15]
           guilt-import - Import specified patch file.

       guilt1[16]
           guilt-init - Initialize guilt for use in a git repository.

       guilt1[17]
           guilt-new - Create a new patch.

       guilt1[18]
           guilt-next - Output the name of next patch to be pushed.

       guilt1[19]
           guilt-patchbomb - Email a series of commits interactively.

       guilt1[20]
           guilt-pop - Pop patches from the tree.

       guilt1[21]
           guilt-prev - Output name of second topmost applied patch.

       guilt1[22]
           guilt-push - Push patches onto the tree.

       guilt1[23]
           guilt-rebase - Rebase pushed patches.

       guilt1[24]
           guilt-refresh - Refresh topmost applied patch.

       guilt1[25]
           guilt-repair - Repair the repository state.

       guilt1[26]
           guilt-rm - Remove a file from the git tree and guilt.

       guilt1[27]
           guilt-series - Print the stack of patches.

       guilt1[28]
           guilt-status - Print the status of files since the last refresh.

       guilt1[29]
           guilt-top - Output name of topmost applied patch.

       guilt1[30]
           guilt-unapplied - List all unapplied patches.

AUTHOR

       Written by Josef "Jeff" Sipek <jeffpc@josefsipek.net>

DOCUMENTATION

       Documentation by Brandon Philips <brandon@ifup.org> and Josef "Jeff"
       Sipek <jeffpc@josefsipek.net>

GUILT

       Part of the guilt7[31] suite (Generated for Guilt )

NOTES

        1. 1
           guilt-delete

        2. 1
           guilt-add

        3. 1
           guilt-applied

        4. 1
           guilt-branch

        5. 1
           guilt-commit

        6. 1
           guilt-diff

        7. 1
           guilt-export

        8. 1
           guilt-files

        9. 1
           guilt-fold

       10. 1
           guilt-fork

       11. 1
           guilt-graph

       12. 1
           guilt-header

       13. 1
           guilt-help

       14. 1
           guilt-import-commit

       15. 1
           guilt-import

       16. 1
           guilt-init

       17. 1
           guilt-new

       18. 1
           guilt-next

       19. 1
           guilt-patchbomb

       20. 1
           guilt-pop

       21. 1
           guilt-prev

       22. 1
           guilt-push

       23. 1
           guilt-rebase

       24. 1
           guilt-refresh

       25. 1
           guilt-repair

       26. 1
           guilt-rm

       27. 1
           guilt-series

       28. 1
           guilt-status

       29. 1
           guilt-top

       30. 1
           guilt-unapplied

       31. 7
           guilt

                                  05/29/2008                          GUILT(7)