Bumped version to 0.9; last minute doc changes

[topgit.git] / README

TopGit - A different patch queue manager


DESCRIPTION
-----------

TopGit aims to make handling of large amounts of interdependent topic
branches easier. In fact, it is designed especially for the case where
you maintain a queue of third-party patches on top of another (perhaps
Git-controlled) project and want to easily organize, maintain and submit
them - TopGit achieves that by keeping a separate topic branch for each
patch and providing some tools to maintain the branches.


INSTALLATION
------------
See the file INSTALL.


RATIONALE
---------

Why not use something like StGIT or Guilt or 'rebase -i' for maintaining
your patch queue?  The advantage of these tools is their simplicity;
they work with patch _series_ and defer to the reflog facility for
version control of patches (reordering of patches is not
version-controlled at all).  But there are several disadvantages - for
one, these tools (especially StGIT) do not actually fit well with plain
Git at all: it is basically impossible to take advantage of the index
effectively when using StGIT.  But more importantly, these tools
horribly fail in the face of a distributed environment.

TopGit has been designed around three main tenets:

        (i) TopGit is as thin a layer on top of Git as possible.  You
still maintain your index and commit using Git; TopGit will only
automate a few indispensable tasks.

        (ii) TopGit is anxious about _keeping_ your history.  It will
never rewrite your history, and all metadata is also tracked by Git,
smoothly and non-obnoxiously.  It is good to have a _single_ point when
the history is cleaned up, and that is at the point of inclusion in the
upstream project; locally, you can see how your patch has evolved and
easily return to older versions.

        (iii) TopGit is specifically designed to work in a distributed
environment.  You can have several instances of TopGit-aware
repositories and smoothly keep them all up-to-date and transfer your
changes between them.

As mentioned above, the main intended use-case for TopGit is tracking
third-party patches, where each patch is effectively a single topic
branch.  In order to flexibly accommodate even complex scenarios when
you track many patches where many are independent but some depend on
others, TopGit ignores the ancient Quilt heritage of patch series and
instead allows the patches to freely form graphs (DAGs just like Git
history itself, only "one level higher").  For now, you have to manually
specify which patches the current one depends on, but TopGit might help
you with that in the future in a darcs-like fashion.

A glossary plug: The union (i.e. merge) of patch dependencies is called
a _base_ of the patch (topic branch).

Of course, TopGit is perhaps not the right tool for you:

        (i) TopGit is not complicated, but StGIT et al. are somewhat
simpler, conceptually.  If you just want to make a linear purely-local
patch queue, deferring to StGIT instead might make more sense.

        (ii) When using TopGit, your history can get a little hairy
over time, especially with all the merges rippling through. ;-)


SYNOPSIS
--------

        ## Create and evolve a topic branch
        $ tg create t/gitweb/pathinfo-action
        tg: Automatically marking dependency on master
        tg: Creating t/gitweb/pathinfo-action base from master...
        $ ..hack..
        $ git commit
        $ ..fix a mistake..
        $ git commit

        ## Create another topic branch on top of the former one
        $ tg create t/gitweb/nifty-links
        tg: Automatically marking dependency on t/gitweb/pathinfo-action
        tg: Creating t/gitweb/nifty-links base from t/gitweb/pathinfo-action...
        $ ..hack..
        $ git commit

        ## Create another topic branch on top of master and submit
        ## the resulting patch upstream
        $ tg create t/revlist/author-fixed master
        tg: Creating t/revlist/author-fixed base from master...
        $ ..hack..
        $ git commit
        $ tg patch -m
        tg: Sent t/revlist/author-fixed
        From: pasky@suse.cz
        To: git@vger.kernel.org
        Cc: gitster@pobox.com
        Subject: [PATCH] Fix broken revlist --author when --fixed-string

        ## Create another topic branch depending on two others non-trivially
        $ tg create t/whatever t/revlist/author-fixed t/gitweb/nifty-links
        tg: Creating t/whatever base from t/revlist/author-fixed...
        tg: Merging t/whatever base with t/gitweb/nifty-links...
        Merge failed!
        tg: Please commit merge resolution and call: tg create
        tg: It is also safe to abort this operation using `git reset --hard`
        tg: but please remember you are on the base branch now;
        tg: you will want to switch to a different branch.
        $ ..resolve..
        $ git commit
        $ tg create
        tg: Resuming t/whatever setup...
        $ ..hack..
        $ git commit

        ## Update a single topic branch and propagate the changes to
        ## a different one
        $ git checkout t/gitweb/nifty-links
        $ ..hack..
        $ git commit
        $ git checkout t/whatever
        $ tg info
        Topic Branch: t/whatever (1 commit)
        Subject: [PATCH] Whatever patch
        Base: 3f47ebc1
        Depends: t/revlist/author-fixed t/gitweb/nifty-links
        Needs update from:
                t/gitweb/nifty-links (1 commit)
        $ tg update
        tg: Updating base with t/gitweb/nifty-links changes...
        Merge failed!
        tg: Please commit merge resolution and call `tg update` again.
        tg: It is also safe to abort this operation using `git reset --hard`,
        tg: but please remember you are on the base branch now;
        tg: you will want to switch to a different branch.
        $ ..resolve..
        $ git commit
        $ tg update
        tg: Updating t/whatever against new base...
        Merge failed!
        tg: Please resolve the merge and commit. No need to do anything else.
        tg: You can abort this operation using `git reset --hard` now
        tg: and retry this merge later using `tg update`.
        $ ..resolve..
        $ git commit

        ## Update a single topic branch and propagate the changes
        ## further through the dependency chain
        $ git checkout t/gitweb/pathinfo-action
        $ ..hack..
        $ git commit
        $ git checkout t/whatever
        $ tg info
        Topic Branch: t/whatever (1/2 commits)
        Subject: [PATCH] Whatever patch
        Base: 0ab2c9b3
        Depends: t/revlist/author-fixed t/gitweb/nifty-links
        Needs update from:
                t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
        $ tg update
        tg: Recursing to t/gitweb/nifty-links...
        [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
        Merge failed!
        [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update` again.
        [t/gitweb/nifty-links] tg: It is also safe to abort this operation using `git reset --hard`,
        [t/gitweb/nifty-links] tg: but please remember you are on the base branch now;
        [t/gitweb/nifty-links] tg: you will want to switch to a different branch.
        [t/gitweb/nifty-links] tg: You are in a subshell. If you abort the merge,
        [t/gitweb/nifty-links] tg: use `exit` to abort the recursive update altogether.
        [t/gitweb/nifty-links] $ ..resolve..
        [t/gitweb/nifty-links] $ git commit
        [t/gitweb/nifty-links] $ tg update
        [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base...
        Merge failed!
        [t/gitweb/nifty-links] tg: Please resolve the merge and commit.
        [t/gitweb/nifty-links] tg: You can abort this operation using `git reset --hard`.
        [t/gitweb/nifty-links] tg: You are in a subshell. After you either commit or abort
        [t/gitweb/nifty-links] tg: your merge, use `exit` to proceed with the recursive update.
        [t/gitweb/nifty-links] $ ..resolve..
        [t/gitweb/nifty-links] $ git commit
        [t/gitweb/nifty-links] $ exit
        tg: Updating base with t/gitweb/nifty-links changes...
        tg: Updating t/whatever against new base...

        ## Clone a TopGit-controlled repository
        $ git clone URL repo
        $ cd repo
        $ tg remote --populate origin
        ...
        $ git fetch
        $ tg update

        ## Add a TopGit remote to a repository and push to it
        $ git remote add foo URL
        $ tg remote foo
        $ tg push -r foo

        ## Update from a non-default TopGit remote
        $ git fetch foo
        $ tg -r foo summary
        $ tg -r foo update


USAGE
-----

The 'tg' tool has several subcommands:

tg help
~~~~~~~
        Our sophisticated integrated help facility.  Mostly duplicates
        what is below, except for adding summary Usage lines.

        # to list commands:
        $ tg help
        # to get help for a particular command:
        $ tg help <command>

tg create
~~~~~~~~~
        Create a new TopGit-controlled topic branch of the given name
        (required argument) and switch to it.  If no dependencies are
        specified (by extra arguments passed after the first one), the
        current branch is assumed to be the only dependency.

        After `tg create`, you should insert the patch description into
        the '.topmsg' file, which will already contain some prefilled
        bits.  You can set the 'topgit.to', 'topgit.cc' and 'topgit.bcc'
        git configuration variables (see `man git-config`) in order to
        have `tg create` add these headers with the given default values
        to '.topmsg'.

        The main task of `tg create` is to set up the topic branch base
        from the dependencies.  This may fail due to merge conflicts.
        In that case, after you commit the conflict resolution, you
        should call `tg create` again (without any arguments); it will
        detect that you are on a topic branch base ref and resume the
        topic branch creation operation.

        In an alternative use case, if '-r BRANCH' is given instead of a
        dependency list, the topic branch is created based on the given
        remote branch.

tg delete
~~~~~~~~~
        Remove a TopGit-controlled topic branch of the given name
        (required argument). Normally, this command will remove only an
        empty branch (base == head) without dependendents; use '-f' to
        remove a non-empty branch or a branch that is depended upon by
        another branch.

        The '-f' option is also useful to force removal of a branch's
        base, if you used `git branch -D B` to remove branch B, and then
        certain TopGit commands complain, because the base of branch B
        is still there.

        IMPORTANT: Currently, this command will _NOT_ remove the branch
        from the dependency list in other branches. You need to take
        care of this _manually_.  This is even more complicated in
        combination with '-f' - in that case, you need to manually
        unmerge the removed branch's changes from the branches depending
        on it.

        TODO: '-a' to delete all empty branches, depfix, revert

tg depend
~~~~~~~~~
        Change the dependencies of a TopGit-controlled topic branch.
        This should have several subcommands, but only `add` is
        supported right now.

        The `add` subcommand takes an argument naming a topic branch to
        be added, adds it to '.topdeps', performs a commit and then
        updates your topic branch accordingly.  If you want to do other
        things related to the dependency addition, like adjusting
        '.topmsg', prepare them in the index before calling `tg depend
        add`.

        TODO: Subcommand for removing dependencies, obviously

tg files
~~~~~~~~
        List files changed by the current or specified topic branch.

        Options:
          -i            list files based on index instead of branch
          -w            list files based on working tree instead of branch

tg info
~~~~~~~
        Show summary information about the current or specified topic
        branch.

tg patch
~~~~~~~~
        Generate a patch from the current or specified topic branch.
        This means that the diff between the topic branch base and head
        (latest commit) is shown, appended to the description found in
        the '.topmsg' file.

        The patch is simply dumped to stdout.  In the future, `tg patch`
        will be able to automatically send the patches by mail or save
        them to files. (TODO)

        Options:
          -i            base patch generation on index instead of branch
          -w            base patch generation on working tree instead of branch

tg mail
~~~~~~~
        Send a patch from the current or specified topic branch as
        email(s).

        Takes the patch given on the command line and emails it out.
        Destination addresses such as To, Cc and Bcc are taken from the
        patch header.

        Since it actually boils down to `git send-email`, please refer
        to the documentation for that for details on how to setup email
        for git.  You can pass arbitrary options to this command through
        the '-s' parameter, but you must double-quote everything.  The
        '-r' parameter with a msgid can be used to generate in-reply-to
        and reference headers to an earlier mail.

        WARNING: be careful when using this command.  It easily sends
        out several mails.  You might want to run

                git config sendemail.confirm always

        to let `git send-email` ask for confirmation before sending any
        mail.

        Options:
          -i            base patch generation on index instead of branch
          -w            base patch generation on working tree instead of branch

        TODO: 'tg mail patchfile' to mail an already exported patch
        TODO: mailing patch series
        TODO: specifying additional options and addresses on command
              line

tg remote
~~~~~~~~~
        Register the given remote as TopGit-controlled. This will create
        the namespace for the remote branch bases and teach `git fetch`
        to operate on them. However, from TopGit 0.8 onwards you need to
        use `tg push`, or `git push --mirror`, for pushing
        TopGit-controlled branches.

        `tg remote` takes an optional remote name argument, and an
        optional '--populate' switch.  Use '--populate' for your
        origin-style remotes: it will seed the local topic branch system
        based on the remote topic branches.  '--populate' will also make
        `tg remote` automatically fetch the remote, and `tg update` look
        at branches of this remote for updates by default.

tg summary
~~~~~~~~~~
        Show overview of all TopGit-tracked topic branches and their
        up-to-date status ('>' marks the current topic branch,
        '0' indicates that it introduces no changes of its own,
        'l'/'r' indicates respectively whether it is local-only or has a remote mate,
        'L'/'R' indicates respectively if it is ahead or out-of-date with respect to its remote mate,
        'D' indicates that it is out-of-date with respect to its dependencies,
        '!' indicates that it has missing dependencies [even if they are recursive ones], and
        'B' indicates that it is out-of-date with respect to its base).

        This can take a long time to accurately determine all the
        relevant information about each branch; you can pass '-t' to get
        just a terse list of topic branch names quickly.  Alternately,
        you can pass '--graphviz' to get a dot-suitable output to draw a
        dependency graph between the topic branches.

        You can also use the '--sort' option to sort the branches using
        a topological sort.  This is especially useful if each
        TopGit-tracked topic branch depends on a single parent branch,
        since it will then print the branches in the dependency order.
        In more complex scenarios, a text graph view would be much more
        useful, but that has not yet been implemented.

        The --deps option outputs dependency information between
        branches in a machine-readable format.  Feed this to `tsort` to
        get the output from --sort.

        Options:
          -i            Use TopGit metadata from the index instead of the branch
          -w            Use TopGit metadata from the working tree instead of the branch

        TODO: Speed up by an order of magnitude
        TODO: Text graph view

tg export
~~~~~~~~~
        Export a tidied-up history of the current topic branch and its
        dependencies, suitable for feeding upstream.  Each topic branch
        corresponds to a single commit or patch in the cleaned up
        history (corresponding basically exactly to `tg patch` output
        for the topic branch).

        The command has three possible outputs now - either a Git branch
        with the collapsed history, a Git branch with a linearized
        history, or a quilt series in new directory.

        In the case where you are producing collapsed history in a new
        branch, you can use this collapsed structure either for
        providing a pull source for upstream, or for further
        linearization e.g. for creation of a quilt series using git log:

                git log --pretty=email -p --topo-order origin..exported

        To better understand the function of `tg export`, consider this
        dependency structure:

        origin/master - t/foo/blue - t/foo/red - master
                     `- t/bar/good <,----------'
                     `- t/baz      ------------'

        (where each of the branches may have a hefty history). Then

        master$ tg export for-linus

        will create this commit structure on the branch 'for-linus':

        origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
                     `- t/bar/good <,-------------------'/
                     `- t/baz      ---------------------'

        In this mode, `tg export` works on the current topic branch, and
        can be called either without an option (in that case,
        '--collapse' is assumed), or with the '--collapse' option, and
        with one mandatory argument: the name of the branch where the
        exported result will be stored.

        WARNING: The branch will be silently overwritten if it exists
        already!  If you make a mistake, use `git reflog` to recover.

        When using the linearize mode:

        master$ tg export --linearize for-linus

        you get a linear history respecting the dependencies of your
        patches in a new branch 'for-linus'.  The result should be more
        or less the same as using quilt mode and then reimporting it
        into a Git branch.  (More or less because the topological order
        can usually be extended in more than one way into a total order,
        and the two methods may choose different ones.)  The result
        might be more appropriate for merging upstream, as it contains
        fewer merges.

        Note that you might get conflicts during linearization because
        the patches are reordered to get a linear history.

        When using the quilt mode,

        master$ tg export --quilt for-linus

        would create the following directory 'for-linus':

        for-linus/t/foo/blue.diff
        for-linus/t/foo/red.diff
        for-linus/t/bar/good.diff
        for-linus/t/baz.diff
        for-linus/series:
                t/foo/blue.diff -p1
                t/bar/good.diff -p1
                t/foo/red.diff -p1
                t/baz.diff -p1

        With '--quilt', you can also pass '-b' parameter followed by
        a comma-separated explicit list of branches to export. This
        mode of operation is currently not supported with '--collapse'.

        In '--quilt' mode the patches are named like the originating
        topgit branch.  So usually they end up in subdirectories of the
        output directory.  With the '--flatten' option the names are
        mangled so that they end up directly in the output dir (slashes
        are substituted by underscores).  With the '--strip[=N]' option
        the first 'N' subdirectories (all if no 'N' is given) get
        stripped off.  Names are always '--strip'ped before being
        '--flatten'ed.  With the option '--numbered' (which implies
        '--flatten') the patch names get a number as prefix to allow
        getting the order without consulting the series file, which
        eases sending out the patches.

        TODO: Make stripping of non-essential headers configurable
        TODO: Make stripping of [PATCH] and other prefixes configurable
        TODO: --mbox option for other mode of operation
        TODO: -a option to export all branches
        TODO: For quilt exporting, export the linearized history created in a
              temporary branch---this would allow producing conflict-less
              series

tg import
~~~~~~~~~
        Import commits within the given revision range into TopGit,
        creating one topic branch per commit. The dependencies are set
        up to form a linear sequence starting on your current branch -
        or a branch specified by the '-d' parameter, if present.

        The branch names are auto-guessed from the commit messages and
        prefixed by 't/' by default; use '-p <prefix>' to specify an
        alternative prefix (even an empty one).

        Alternatively, you can use the '-s NAME' parameter to specify
        the name of the target branch; the command will then take one
        more argument describing a _single_ commit to import.

tg update
~~~~~~~~~
        Update the current, specified or all topic branches with respect
        to changes in the branches they depend on and remote branches.
        This is performed in two phases - first, changes within the
        dependencies are merged to the base, then the base is merged
        into the topic branch.  The output will guide you on what to do
        next in case of conflicts.

        When '-a' is specifed, updates all topic branches matched by
        <pattern>s (see `git-for-all-refs(1)` for details), or all if
        no <pattern> is given.

        After the update, if a single topic branch was specified, it is
        left as the current one; if '-a' was specified, it returns to
        the branch which was current at the beginning.

        If your dependencies are not up-to-date, `tg update` will first
        recurse into them and update them.

        If a remote branch update brings in dependencies on branches
        that are not yet instantiated locally, you can either bring in
        all the new branches from the remote using `tg remote
        --populate`, or only pick out the missing ones using `tg create
        -r` (`tg summary` will point out branches with incomplete
        dependencies by showing an '!' next to them).

        TODO: tg update -a -c to autoremove (clean) up-to-date branches

tg push
~~~~~~~
        pushes a TopGit-controlled topic branch - the current branch, if
        you don't specify which - to a remote repository.  By default,
        the remote gets all the dependencies (both TopGit-controlled and
        non-TopGit-controlled) and bases pushed to it too.

tg base
~~~~~~~
        Prints the base commit of the current topic branch.  Silently
        exits with exit code 1 if you are not working on a TopGit
        branch.

tg log
~~~~~~
        Prints the git log of the named topgit branch - or the current
        branch, if you don't specify a name.

        NOTE: if you have merged changes from a different repository, this
        command might not list all interesting commits.

tg prev
~~~~~~~
        Outputs the direct dependencies for the current or named branch.

        Options:
          -i            show dependencies based on index instead of branch
          -w            show dependencies based on working tree instead of branch

tg next
~~~~~~~
        Outputs all branches which directly depend on the current or
        named branch.

        Options:
          -i            show dependencies based on index instead of branch
          -w            show dependencies based on working tree instead of branch

TODO: tg rename

IMPLEMENTATION
--------------

TopGit stores all the topic branches in the regular 'refs/heads/'
namespace (so we recommend distinguishing them with the 't/' prefix).
Apart from that, TopGit also maintains a set of auxiliary refs in
'refs/top-*'.  Currently, only refs/top-bases/ is used, containing the
current _base_ of the given topic branch - this is basically a merge of
all the branches the topic branch depends on; it is updated during `tg
update` and then merged to the topic branch, and it is the base of a
patch generated from the topic branch by `tg patch`.

All the metadata is tracked within the source tree and history of the
topic branch itself, in .top* files; these files are kept isolated
within the topic branches during TopGit-controlled merges and are of
course omitted during `tg patch`.  The state of these files in base
commits is undefined; look at them only in the topic branches
themselves.  Currently, two files are defined:

        '.topmsg': Contains the description of the topic branch in a
mail-like format, plus the author information, whatever Cc headers you
choose or the post-three-dashes message.  When mailing out your patch,
basically only a few extra mail headers are inserted and then the patch
itself is appended.  Thus, as your patches evolve, you can record
nuances like whether the particular patch should have To-list /
Cc-maintainer or vice-versa and similar nuances, if your project is into
that.  'From' is prefilled from your current `GIT_AUTHOR_IDENT`; other
headers can be prefilled from various optional 'topgit.*' git config
options.

        '.topdeps': Contains the one-per-line list of branches this
branch depends on, pre-seeded by `tg create`. A (continuously updated)
merge of these branches will be the "base" of your topic branch.

IMPORTANT: DO NOT EDIT '.topdeps' MANUALLY!!! If you do so, you need to
know exactly what are you doing, since this file must stay in sync with
the Git history information, otherwise very bad things will happen.

TopGit also automagically installs a bunch of custom commit-related
hooks that will verify whether you are committing the '.top*' files in a
sane state. It will add the hooks to separate files within the 'hooks/'
subdirectory, and merely insert calls to them to the appropriate hooks
and make them executable (but will make sure the original hook's code is
not called if the hook was not executable beforehand).

Another automagically installed piece is a '.git/info/attributes'
specifier for an 'ours' merge strategy for the files '.topmsg' and
'.topdeps', and the (intuitive) 'ours' merge strategy definition in
'.git/config'.


REMOTE HANDLING
---------------

There are two remaining issues with accessing topic branches in remote
repositories:

        (i) Referring to remote topic branches from your local repository
        (ii) Developing some of the remote topic branches locally

There are two somewhat contradictory design considerations here:

        (a) Hacking on multiple independent TopGit remotes in a single
        repository
        (b) Having a self-contained topic system in local refs space

To us, (a) does not appear to be very convincing, while (b) is quite
desirable for 'git-log topic' etc. working, and increased conceptual
simplicity.

Thus, we choose to instantiate all the topic branches of given remote
locally; this is performed by `tg remote --populate`. `tg update` will
also check if a branch can be updated from its corresponding remote
branch.  The logic needs to be somewhat involved if we are to "do the
right thing".  First, we update the base, handling the remote branch as
if it was the first dependency; thus, conflict resolutions made in the
remote branch will be carried over to our local base automagically.
Then, the base is merged into the remote branch and the result is merged
to the local branch - again, to carry over remote conflict resolutions.
In the future, this order might be adjustable on a per-update basis, in
case local changes happen to be diverging more than the remote ones.

All commands by default refer to the remote that `tg remote --populate`
was called on the last time (stored in the 'topgit.remote' git
configuration variable). You can manually run any command with a
different base remote by passing '-r REMOTE' _before_ the subcommand
name.


REFERENCES
----------

The following references are useful to understand the development of
topgit and its subcommands.

* tg depend:
  http://lists-archives.org/git/688698-add-list-and-rm-sub-commands-to-tg-depend.html


THIRD-PARTY SOFTWARE
--------------------

The following software understands TopGit branches:

* http://magit.github.com/magit/[magit] - a git mode for emacs

IMPORTANT: Magit requires its topgit mode to be enabled first, as
described in its documentation, in the "Activating extensions"
subsection.  If this is not done, it will not push TopGit branches
correctly, so it's important to enable it even if you plan to mostly use
TopGit from the command line.