README: fix typo
[topgit/pro.git] / README
blob6b1a2426399b6e4b2a9feec6a420e184966540ec
1 =========================================
2 TopGit -- A different patch queue manager
3 =========================================
6 DESCRIPTION
7 -----------
9 TopGit aims to make handling of large amounts of interdependent topic
10 branches easier. In fact, it is designed especially for the case where
11 you maintain a queue of third-party patches on top of another (perhaps
12 Git-controlled) project and want to easily organize, maintain and submit
13 them -- TopGit achieves that by keeping a separate topic branch for each
14 patch and providing some tools to maintain the branches.
16 See also:
18         :REQUIREMENTS_:     Installation requirements
19         :USAGE_:            Command Line details
20         :`NO UNDO`_:        Where's the undo!!!
21         :CONVENTIONS_:      Suggestions for organizing your TopGit branches
22         :GLOSSARY_:         All the TopGit vocabulary in one place
23         :TECHNICAL_:        How it works behind the scenes
26 REQUIREMENTS
27 ------------
29 TopGit is a collection of POSIX shell scripts so a POSIX-compliant shell is
30 required along with some standard POSIX-compliant utilities (e.g. sed, awk,
31 cat, etc.).  Git version 1.8.5 or later is also required.
33 The scripts need to be preprocessed and installed and currently the Makefile
34 that does this requires GNU make, but that's an install-time-only requirement.
36 It is possible, however, to use the DESTDIR functionality to install TopGit to
37 a staging area on one machine, archive that and then unarchive it on another
38 machine to perform an install (provided the build prefix and other options are
39 compatible with the final installed location).
42 INSTALLATION
43 ------------
45 See the file ``INSTALL``.
48 GIT REPOSITORY
49 --------------
51 The TopGit git repository can be found at <http://repo.or.cz/topgit/pro>.
54 RATIONALE
55 ---------
57 Why not use something like StGIT or Guilt or ``rebase -i`` for maintaining
58 your patch queue?  The advantage of these tools is their simplicity;
59 they work with patch *series* and defer to the reflog facility for
60 version control of patches (reordering of patches is not
61 version-controlled at all).  But there are several disadvantages -- for
62 one, these tools (especially StGIT) do not actually fit well with plain
63 Git at all: it is basically impossible to take advantage of the index
64 effectively when using StGIT.  But more importantly, these tools
65 horribly fail in the face of a distributed environment.
67 TopGit has been designed around three main tenets:
69         (i) TopGit is as thin a layer on top of Git as possible.  You
70         still maintain your index and commit using Git; TopGit will only
71         automate a few indispensable tasks.
73         (ii) TopGit is anxious about *keeping* your history.  It will
74         never rewrite your history, and all metadata is also tracked
75         by Git, smoothly and non-obnoxiously.  It is good to have a
76         *single* point when the history is cleaned up, and that is at
77         the point of inclusion in the upstream project; locally, you
78         can see how your patch has evolved and easily return to older
79         versions.
81         (iii) TopGit is specifically designed to work in a
82         distributed environment.  You can have several instances of
83         TopGit-aware repositories and smoothly keep them all
84         up-to-date and transfer your changes between them.
86 As mentioned above, the main intended use-case for TopGit is tracking
87 third-party patches, where each patch is effectively a single topic
88 branch.  In order to flexibly accommodate even complex scenarios when
89 you track many patches where many are independent but some depend on
90 others, TopGit ignores the ancient Quilt heritage of patch series and
91 instead allows the patches to freely form graphs (DAGs just like Git
92 history itself, only "one level higher").  For now, you have to manually
93 specify which patches the current one depends on, but TopGit might help
94 you with that in the future in a darcs-like fashion.
96 A glossary_ plug: The union (i.e. merge) of patch dependencies is called
97 a *base* of the patch (topic branch).
99 Of course, TopGit is perhaps not the right tool for you:
101         (i) TopGit is not complicated, but StGIT et al. are somewhat
102         simpler, conceptually.  If you just want to make a linear
103         purely-local patch queue, deferring to StGIT instead might
104         make more sense.
106         (ii) When using TopGit, your history can get a little hairy
107         over time, especially with all the merges rippling through.
108         ;-)
111 SYNOPSIS
112 --------
116         ## Create and evolve a topic branch
117         $ tg create t/gitweb/pathinfo-action
118         tg: Automatically marking dependency on master
119         tg: Creating t/gitweb/pathinfo-action base from master...
120         $ ..hack..
121         $ git commit
122         $ ..fix a mistake..
123         $ git commit
125         ## Create another topic branch on top of the former one
126         $ tg create t/gitweb/nifty-links
127         tg: Automatically marking dependency on t/gitweb/pathinfo-action
128         tg: Creating t/gitweb/nifty-links base from t/gitweb/pathinfo-action...
129         $ ..hack..
130         $ git commit
132         ## Create another topic branch on top of master and submit
133         ## the resulting patch upstream
134         $ tg create t/revlist/author-fixed master
135         tg: Creating t/revlist/author-fixed base from master...
136         $ ..hack..
137         $ git commit
138         $ tg patch -m
139         tg: Sent t/revlist/author-fixed
140         From: pasky@suse.cz
141         To: git@vger.kernel.org
142         Cc: gitster@pobox.com
143         Subject: [PATCH] Fix broken revlist --author when --fixed-string
145         ## Create another topic branch depending on two others non-trivially
146         $ tg create t/whatever t/revlist/author-fixed t/gitweb/nifty-links
147         tg: Creating t/whatever base from t/revlist/author-fixed...
148         tg: Merging t/whatever base with t/gitweb/nifty-links...
149         Merge failed!
150         tg: Please commit merge resolution and call: tg create --continue
151         tg: It is also safe to abort this operation using `git reset --hard`
152         tg: but please remember you are on the base branch now;
153         tg: you will want to switch to a different branch.
154         $ ..resolve..
155         $ git commit
156         $ tg create --continue
157         tg: Resuming t/whatever setup...
158         $ ..hack..
159         $ git commit
161         ## Update a single topic branch and propagate the changes to
162         ## a different one
163         $ git checkout t/gitweb/nifty-links
164         $ ..hack..
165         $ git commit
166         $ git checkout t/whatever
167         $ tg info
168         Topic Branch: t/whatever (1 commit)
169         Subject: [PATCH] Whatever patch
170         Base: 3f47ebc1
171         Depends: t/revlist/author-fixed t/gitweb/nifty-links
172         Needs update from:
173                 t/gitweb/nifty-links (1 commit)
174         $ tg update
175         tg: Updating base with t/gitweb/nifty-links changes...
176         Merge failed!
177         tg: Please commit merge resolution and call `tg update --continue`
178         tg: (use `tg status` to see more options)
179         $ ..resolve..
180         $ git commit
181         $ tg update --continue
182         tg: Updating t/whatever against new base...
183         Merge failed!
184         tg: Please commit merge resolution and call `tg update --continue`
185         tg: (use `tg status` to see more options)
186         $ ..resolve..
187         $ git commit
188         $ tg update --continue
190         ## Update a single topic branch and propagate the changes
191         ## further through the dependency chain
192         $ git checkout t/gitweb/pathinfo-action
193         $ ..hack..
194         $ git commit
195         $ git checkout t/whatever
196         $ tg info
197         Topic Branch: t/whatever (1/2 commits)
198         Subject: [PATCH] Whatever patch
199         Base: 0ab2c9b3
200         Depends: t/revlist/author-fixed t/gitweb/nifty-links
201         Needs update from:
202                 t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
203         $ tg update
204         tg: Recursing to t/gitweb/nifty-links...
205         [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
206         Merge failed!
207         [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
208         [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
209         $ ..resolve..
210         $ git commit
211         $ tg update --continue
212         [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base...
213         Merge failed!
214         [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
215         [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
216         $ ..resolve..
217         $ git commit
218         $ tg update --continue
219         tg: Updating base with t/gitweb/nifty-links changes...
220         tg: Updating t/whatever against new base...
222         ## Clone a TopGit-controlled repository
223         $ git clone URL repo
224         $ cd repo
225         $ tg remote --populate origin
226         ...
227         $ git fetch
228         $ tg update
230         ## Add a TopGit remote to a repository and push to it
231         $ git remote add foo URL
232         $ tg remote foo
233         $ tg push -r foo
235         ## Update from a non-default TopGit remote
236         $ git fetch foo
237         $ tg -r foo summary
238         $ tg -r foo update
241 CONVENTIONS
242 -----------
244 When using TopGit there are several common conventions used when working with
245 TopGit branches.  None of them are enforced, they are only suggestions.
247 There are three typical uses for a TopGit branch:
249     1. [PATCH]
250        Normal TopGit branches that represent a single patch.  These are known
251        as "patch" TopGit branches.
252     2. [BASE]
253        Empty TopGit branches with no dependencies (an empty ``.topdeps`` file)
254        that represent a base upon which other "normal" TopGit branches depend.
255        These are known as "base" TopGit branches (not to be confused with
256        the refs/top-bases/... refs).
257     3. [STAGE]
258        Empty TopGit branches that serve as a staging area to bring together
259        several other TopGit branches into one place so they can be used/tested
260        all together.  These are known as "stage" TopGit branches.
262 An "empty" TopGit branch is one that does not have any changes of its own --
263 it may still have dependencies though ("stage" branches do, "base" branches do
264 not).  The ``tg summary`` output shows empty branches with a ``0`` in the
265 listing.  Normal "patch" branches that have not been annihilated, "base" and
266 "stage" branches fall into this category.  (Annihilated branches are normally
267 omitted from the ``tg summary`` output but can be shown if given explicitly as
268 an argument to the ``tg summary`` command.  However, the message line will be
269 incorrect since an annihilated branch has no ``.topmsg`` file of its own.)
271 A "patch" branch name typically starts with ``t/`` whereas "base" and "stage"
272 branch names often do not.
274 A "base" branch is created by using the ``--no-deps`` option of ``tg create``
275 which will automatically suggest a "[BASE]" message prefix rather than
276 "[PATCH]".  A "stage" branch is created like a normal patch branch except that
277 the only changes that will ever be made to it are typically to add/remove
278 dependencies.  Its subject prefix must be manually changed to "[STAGE]" to
279 reflect its purpose.
281 Since both "base" and "stage" branches typically only have a use for the
282 "Subject:" ilne from their ``.topmsg`` file, they are quite easily created
283 using the ``--topmsg`` option of ``tg create``.
285 Use of "stage" and "base" branches is completely optional.  However, without
286 use of a "stage" branch it will be difficult to test multiple independent
287 patches together all at once.  A "base" branch is merely a convenience that
288 provides more explicit control over when a common base for a set of patches
289 gets updated as well as providing a branch that shows in ``tg summary`` output
290 and participates in ``tg remote --populate`` setup.
292 When using the ``tg tag`` command to create tags that record the current state
293 of one or more TopGit branches, the tags are often created with a name that
294 starts with ``t/``.
296 One last thing, you have enabled ``git rerere`` haven't you?
299 NO UNDO
300 -------
302 Beware, there is no "undo" after running a ``tg update``!
304 Well, that's not entirely correct.  Since ``tg update`` never discards commits
305 an "undo" operation is technically feasible provided the old values of all the
306 refs that were affected by the ``tg update`` operation can be determined and
307 then they are simply changed back to their previous values.
309 In practice though, it can be extremely tedious and error prone looking through
310 log information to try and determine what the correct previous values were.
311 Although, since TopGit tries to make sure reflogs are enabled for top-bases
312 refs, using Git's ``@{date}`` notation on all the refs dumped out by a
313 ``tg tag --refs foo``, where "foo" is the branch that was updated whose update
314 needs to be undone, may work.
316 Alternatively, ``tg tag --stash`` can be used prior to the update and then
317 ``tg revert`` used after the update to restore the previous state.  This
318 assumes, of course, that you remember to run ``tg tag --stash`` first.
320 The ``tg update`` command understands a ``--stash`` option that tells it to
321 automatically run ``tg tag --stash`` before it starts making changes (if
322 everything is up-to-date it won't run the stash command at all).
324 The ``--stash`` option is the default nowadays when running ``tg update``,
325 add the ``--no-stash`` option to turn it off.
327 There is a preference for this.  Setting the config value ``topgit.autostash``
328 to ``false`` will implicitly add the ``--no-stash`` option to any ``tg update``
329 command unless an explicit ``--stash`` option is given.
331 If you are likely to ever want to undo a ``tg update``, setting
332 ``topgit.autostash`` to ``false`` is highly discouraged!
334 Note that the tags saved by ``tg tag --stash`` are stored in the
335 ``refs/tgstash`` ref and its reflog.  Unfortunately, while Git is happy to
336 maintain the reflog (once it's been enabled which ``tg tag`` guarantees for
337 ``refs/tgstash``), Git is unable to view an annotated/signed tag's reflog!
338 Instead Git dereferences the tag and shows the wrong thing.  Use the
339 ``tg tag -g`` command to view the ``refs/tgstash`` reflog instead.
342 SEQUESTRATION
343 -------------
345 No, this is not a section about budget nonsense.  ;)
347 TopGit keeps its metadata in ``.topdeps`` and ``.topmsg`` files.  In an effort
348 to facilitate cherry-picking and other Git activities on the patch changes
349 themselves while ignoring the TopGit metadata, TopGit attempts to keep all
350 changes to ``.topdeps`` and ``.topmsg`` files limited to commits that do NOT
351 contain changes to any other files.
353 This is a departure from previous TopGit versions that made no such effort.
355 Primarily this affects ``tg create`` and ``tg import`` (which makes use of
356 ``tg create``) as ``tg create`` will commit the initial versions of
357 ``.topdeps`` and ``.topmsg`` for a new TopGit-controlled branch in their own
358 commit instead of mixing them in with changes to other files.
360 The ``pre-commit`` hook will also attempt to separate out any ``.topdeps`` and
361 ``.topmsg`` changes from commits that include changes to other files.
363 It is possible to defeat these checks without much effort (``pre-commit`` hooks
364 can easily be bypassed, ``tg create`` has a ``--no-commit`` option, many Git
365 commands simply do not run the ``pre-commit`` hook, etc.).
367 If you really, really, really, really want to change the default back to the
368 old behavior of previous TopGit versions where no such sequestration took
369 place, then set the ``topgit.sequester`` config variable explicitly to the
370 value ``false``.  But this is not recommended.
373 AMENDING AND REBASING AND UPDATE-REF'ING
374 ----------------------------------------
376 In a word, "don't".
378 It is okay to manually update a top-bases/... ref when a) it has no depedencies
379 (i.e. it was created with the ``tg create`` ``--no-deps`` option) and b) the
380 old top-bases/... ref value can be fast-forwarded to the new top-bases/...
381 value OR the new value contains ALL of the changes in the old value through
382 some other mechanism (perhaps they were cherry-picked or otherwise applied to
383 the new top-bases/... ref).  The same rules apply to non-TopGit-controlled
384 dependencies.
386 Ignoring this rule and proceeding anyway with a non-fast-forward update to a
387 top-bases/... ref will result in changes present in the new value being merged
388 into the branch (at ``tg update`` time) as expected (possibly with conflicts),
389 but any changes that were contained in the old version of the top-bases/... ref
390 which have been dropped (i.e. are NOT contained in the new version of the
391 top-bases/... ref) will continue to be present in the branch!  To get rid of
392 the dropped commits, one or more "revert" commits will have to be manually
393 applied to the tip of the new top-bases/... value (which will then be merged
394 into the branch at next ``tg update`` time).
396 The only time it's safe to amend, rebase, filter or otherwise rewrite commits
397 contained in a TopGit controlled branch or non-TopGit branch is when those
398 commits are NOT reachable via any other ref!
400 Furthermore, while it is safe to rewrite merge commits (provided they meet the
401 same conditions) the merge commits themselves and the branches they are merging
402 in must be preserved during the rewrite and that can be rather tricky to get
403 right so it's not recommended.
405 For example, if, while working on a TopGit-controlled branch ``foo``, a bad
406 typo is noticed, it's okay to ammend/rebase to fix that provided neither
407 ``tg update`` nor ``tg create`` has already been used to cause some other ref
408 to be able to reach the commit with the typo.
410 If an amend or rerwite is done anyway even though the commit with the typo is
411 reachable from some other ref, the typo won't really be removed.  What will
412 happen instead is that the new version without the typo will ultimately be
413 merged into the other ref(s) (at ``tg update`` time) likely causing a conflict
414 that will have to be manually resolved and the commit with the typo will
415 continue to be reachable from those other refs!
417 Instead just make a new commit to fix the typo.  The end result will end up
418 being the same but without the merge conflicts.
420 See also the discussion in the `NO UNDO`_ section.
423 SPEED AND CACHING
424 -----------------
426 TopGit needs to check many things to determine whether a TopGit branch is
427 up-to-date or not.  This can involve a LOT of git commands for a complex
428 dependency tree.  In order to speed things up, TopGit keeps a cache of results
429 in a ``tg-cache`` subdirectory in the ``.git`` directory.
431 Results are tagged with the original hash values used to get that result so
432 that items which have not been changed return their results quickly and items
433 which have been changed compute their new result and cache it for future use.
435 The ``.git/tg-cache`` directory may be removed at any time and the cache will
436 simply be recreated in an on-demand fashion as needed, at some speed penalty,
437 until it's fully rebuilt.
439 To force the cache to be fully pre-loaded, run the ``tg summary`` command
440 without any arguments.  Otherwise, normal day-to-day TopGit operations should
441 keep it more-or-less up-to-date.
443 While each TopGit command is running, it uses a temporary subdirectory also
444 located in the ``.git`` directory.  These directories are named
445 ``tg-tmp.XXXXXX`` where the ``XXXXXX`` part will be random letters and digits.
447 These temporary directories should always be removed automatically after each
448 TopGit command finishes running.  As long as you are not in a subshell as a
449 result of a TopGit command stopping and waiting for a manual merge resolution,
450 it's safe to remove any of these directories that may have somehow accidentally
451 been left behind as a result of some failure that occurred while running a
452 TopGit command (provided, of course, it's not actually being used by a TopGit
453 command currently running in another terminal window or by another user on the
454 same repository).
457 USAGE
458 -----
459 ``tg [-C <dir>] [-r <remote> | -u] [-c <name>=<val>] <subcommand> [<subcommand option/argument>...]``
461         -C <dir>        Change directory to <dir> before doing anything
462         -r <remote>     Pretend ``topgit.remote`` is set to <remote>
463         -u              Pretend ``topgit.remote`` is not set
464         -c <name=val>   Pass config option to git, may be repeated
466 The ``tg`` tool has several subcommands:
468         :`tg annihilate`_:  Mark a TopGit-controlled branch as defunct
469         :`tg base`_:        Show base commit for one or more TopGit branches
470         :`tg checkout`_:    Shortcut for git checkout with name matching
471         :`tg create`_:      Create a new TopGit-controlled branch
472         :`tg delete`_:      Delete a TopGit-controlled branch cleanly
473         :`tg depend`_:      Add a new dependency to a TopGit-controlled branch
474         :`tg export`_:      Export TopGit branch patches to files or a branch
475         :`tg files`_:       Show files changed by a TopGit branch
476         :`tg help`_:        Show TopGit help optionally using a browser
477         :`tg import`_:      Import commit(s) to separate TopGit branches
478         :`tg info`_:        Show status information about a TopGit branch
479         :`tg log`_:         Run git log limiting revisions to a TopGit branch
480         :`tg mail`_:        Shortcut for git send-email with ``tg patch`` output
481         :`tg migrate-bases`_: Transition top-bases to new location
482         :`tg next`_:        Show branches directly depending on a TopGit branch
483         :`tg patch`_:       Generate a patch file for a TopGit branch
484         :`tg prev`_:        Show non-annihilated TopGit dependencies for a branch
485         :`tg push`_:        Run git push on TopGit branch(es) and depedencies
486         :`tg rebase`_:      Auto continue git rebase if rerere resolves conflicts
487         :`tg remote`_:      Set up remote for fetching/pushing TopGit branches
488         :`tg revert`_:      Revert ref(s) to a state stored in a ``tg tag``
489         :`tg status`_:      Show current TopGit status (e.g. in-progress update)
490         :`tg summary`_:     Show various information about TopGit branches
491         :`tg tag`_:         Create tag that records current TopGit branch state
492         :`tg update`_:      Update TopGit branch(es) with respect to dependencies
494 tg help
495 ~~~~~~~
496         Our sophisticated integrated help facility.  Mostly duplicates
497         what is below::
499          # to list commands:
500          $ tg help
501          # to get help for a particular command:
502          $ tg help <command>
503          # to get help for a particular command in a browser window:
504          $ tg help -w <command>
505          # to get help on TopGit itself
506          $ tg help tg
507          # to get help on TopGit itself in a browser
508          $ tg help -w tg
510 tg status
511 ~~~~~~~~~
512         Our sophisticated status facility.  Similar to Git's status command
513         but shows any in-progress update that's awaiting a merge resolution
514         or any other on-going TopGit activity (such as a branch creation).
516         With the ``--exit-code`` option the exit code will be non-zero if any
517         TopGit or Git operation is currently in progress or the working
518         tree is unclean.
520 tg create
521 ~~~~~~~~~
522         Create a new TopGit-controlled topic branch of the given name
523         (required argument) and switch to it.  If no dependencies are
524         specified (by extra arguments passed after the first one), the
525         current branch is assumed to be the only dependency.
527         By default ``tg create`` opens an editor on the new ``.topmsg`` file
528         and then commits the new ``.topmsg`` and ``.topdeps`` files
529         automatically with a suitable default commit message.
531         The commit message can be changed with the ``-m`` (or ``--message``) or
532         ``-F`` (or ``--file``) option.  The automatic commit can be suppressed
533         by using the ``--no-ccmmit`` option.  Running the editor on the new
534         ``.topmsg`` file can be suppressed by using ``-n`` (or ``--no-edit``)
535         (which also suppresses the automatic commit) or by providing an
536         explicit value for the new ``.topmsg`` file using the ``--topmsg`` or
537         ``--topmsg-file`` option.  In any case the ``.topmsg`` content will be
538         automatically reformated to have a ``Subject:`` header line if needed.
540         If more than one dependency is listed, the automatic commit will not
541         take place until AFTER all the listed dependencies have been merged
542         into a base commit which will require some manual merge resolutions if
543         conflicts occur during the merge operations.
545         Previous versions of TopGit behaved as though the ``--no-edit`` option
546         was always given on the command line.
548         The default behavior has been changed to promote a separation between
549         commits that modify ``.topmsg`` and/or ``.topdeps`` and commits that
550         modify other files.  This facilitates cleaner cherry picking and other
551         patch maintenance activities.
553         You should edit the patch description (contained in the ``.topmsg``
554         file) as appropriate.  It will already contain some prefilled bits.
555         You can set the ``topgit.to``, ``topgit.cc`` and ``topgit.bcc``
556         git configuration variables (see ``man git-config``) in order to
557         have ``tg create`` add these headers with the given default values
558         to ``.topmsg`` before invoking the editor.
560         The main task of ``tg create`` is to set up the topic branch base
561         from the dependencies.  This may fail due to merge conflicts if more
562         than one dependencie is given.  In that case, after you commit the
563         conflict resolution, you should call ``tg create`` again (without any
564         arguments or with the single argument ``--continue``); it will then
565         detect that you are on a topic branch base ref and resume the topic
566         branch creation operation.
568         With the ``--no-deps`` option at most one dependency may be listed
569         which may be any valid committish (instead of just refs/heads/...) and
570         the newly created TopGit-controlled branch will have an empty
571         ``.topdeps`` file.  This may be desirable in order to create a TopGit-
572         controlled branch that has no changes of its own and serves merely to
573         mark the common dependency that all other TopGit-controlled branches
574         in some set of TopGit-controlled branches depend on.  A plain,
575         non-TopGit-controlled branch can be used for the same purpose, but the
576         advantage of a TopGit-controlled branch with no dependencies is that it
577         will be pushed with ``tg push``, it will show up in the ``tg summary``
578         and ``tg info`` output with the subject from its ``.topmsg`` file
579         thereby documenting what it's for and finally it can be set up with
580         ``tg create -r`` and/or ``tg remote --populate`` to facilitate sharing.
582         For example, ``tg create --no-deps release v2.1`` will create a TopGit-
583         controlled ``release`` branch based off the ``v2.1`` tag that can then
584         be used as a base for creation of other TopGit-controlled branches.
585         Then when the time comes to move the base for an entire set of changes
586         up to ``v2.2`` the command ``git update-ref top-bases/release v2.2^0``
587         can be used followed by ``tg update --all``.  Note that it's only safe
588         to update ``top-bases/release`` directly in this manner because a) it
589         has no depedencies since it was created with the ``--no-deps`` option
590         and b) the old ``top-bases/release`` value can be fast-forwarded to the
591         new ``top-bases/release`` value.
593         Using ``--no-deps`` it's also possible to use ``tg create`` on an
594         unborn branch (omit the dependency name or specify ``HEAD``).  The
595         unborn branch itself can be made into the new TopGit branch (rather
596         than being born empty and then having the new TopGit branch based off
597         that) by specifying ``HEAD`` as the new branch's name (which is
598         probably what you normally want to do in this case anyway so you can
599         just run ``tg create --no-deps HEAD`` to accomplish that).
601         In an alternative use case, if ``-r <branch>`` is given instead of a
602         dependency list, the topic branch is created based on the given
603         remote branch.  With just ``-r`` the remote branch name is assumed
604         to be the same as the local topic branch being created.  Since no
605         new commits are created in this mode (only two refs will be updated)
606         the editor will never be run for this use case.  Note that no other
607         options may be combined with ``-r``.
609         The ``--quiet`` (or ``-q``) option suppresses most informational
610         messages.
612 tg delete
613 ~~~~~~~~~
614         Remove a TopGit-controlled topic branch of the given name
615         (required argument). Normally, this command will remove only an
616         empty branch (base == head) without dependendents; use ``-f`` to
617         remove a non-empty branch or a branch that is depended upon by
618         another branch.
620         The ``-f`` option is also useful to force removal of a branch's
621         base, if you used ``git branch -D B`` to remove branch B, and then
622         certain TopGit commands complain, because the base of branch B
623         is still there.
625         Normally ``tg delete`` will refuse to delete the current branch.
626         However, giving ``-f`` twice (or more) will force it to do so but it
627         will first detach your HEAD.
629         IMPORTANT: Currently, this command will *NOT* remove the branch
630         from the dependency list in other branches. You need to take
631         care of this *manually*.  This is even more complicated in
632         combination with ``-f`` -- in that case, you need to manually
633         unmerge the removed branch's changes from the branches depending
634         on it.
636         See also ``tg annihilate``.
638         | TODO: ``-a`` to delete all empty branches, depfix, revert
640 tg annihilate
641 ~~~~~~~~~~~~~
642         Make a commit on the current TopGit-controlled topic branch
643         that makes it equal to its base, including the presence or
644         absence of .topmsg and .topdeps.  Annihilated branches are not
645         displayed by ``tg summary``, so they effectively get out of your
646         way.  However, the branch still exists, and ``tg push`` will
647         push it (except if given the ``-a`` option).  This way, you can
648         communicate that the branch is no longer wanted.
650         When annihilating a branch that has dependents (i.e. branches
651         that depend on it), those dependents have the dependencies of
652         the branch being annihilated added to them if they do not already
653         have them as dependencies.  Essentially the DAG is repaired to
654         skip over the annihilated branch.
656         Normally, this command will remove only an empty branch
657         (base == head, except for changes to the .top* files); use
658         ``-f`` to annihilate a non-empty branch.
660         After completing the annihilation itself, normally ``tg update``
661         is run on any modified dependents.  Use the ``--no-update`` option
662         to suppress running ``tg update``.
664 tg depend
665 ~~~~~~~~~
666         Change the dependencies of a TopGit-controlled topic branch.
667         This should have several subcommands, but only ``add`` is
668         supported right now.
670         The ``add`` subcommand takes an argument naming a topic branch to
671         be added, adds it to ``.topdeps``, performs a commit and then
672         updates your topic branch accordingly.  If you want to do other
673         things related to the dependency addition, like adjusting
674         ``.topmsg``, use the option ``--no-commit``.  Adding the
675         ``--no-update`` (or ``--no-commit``) option will suppress the
676         ``tg update`` normally performed after committing the change.
678         It is safe to run ``tg depend add`` in a dirty worktree, but the
679         normally performed ``tg update`` will be suppressed in that case
680         (even if neither ``--no-update`` nor ``--no-commit`` is given).
682         You have enabled ``git rerere`` haven't you?
684         | TODO: Subcommand for removing dependencies, obviously
686 tg files
687 ~~~~~~~~
688         List files changed by the current or specified topic branch.
690         Options:
691           -i            list files based on index instead of branch
692           -w            list files based on working tree instead of branch
694 tg info
695 ~~~~~~~
696         Show summary information about the current or specified topic
697         branch.
699         Numbers in parenthesis after a branch name such as "(11/3 commits)"
700         indicate how many commits on the branch (11) and how many of those
701         are non-merge commits (3).
703         Alternatively, if ``--heads`` is used then which of the independent
704         TopGit branch heads (as output by ``tg summary --tgish-only --heads)``
705         contains the specified commit (which may be any committish -- defaults
706         to ``HEAD`` if not given).  Zero or more results will be output.
708         If ``--leaves`` is used then the unique list of leaves of the current
709         or specified topic branch is shown as one fully-qualified ref per line.
710         Duplicates are suppressed and a tag name will be used when appropriate.
711         A "leaf" is any dependency that is either not a TopGit branch or is
712         the base of a non-annihilated TopGit branch with no non-annihilated
713         dependencies.
715         A linearized patch series can only be automatically created for a
716         TopGit topic branch (including its recursive dependencies) when exactly
717         one line is output by ``tg info --leaves <topic-branch>``.
719 tg patch
720 ~~~~~~~~
721         Generate a patch from the current or specified topic branch.
722         This means that the diff between the topic branch base and head
723         (latest commit) is shown, appended to the description found in
724         the ``.topmsg`` file.
726         The patch is simply dumped to stdout.  In the future, ``tg patch``
727         will be able to automatically send the patches by mail or save
728         them to files. (TODO)
730         Options:
731           -i            base patch generation on index instead of branch
732           -w            base patch generation on working tree instead of branch
733           --binary      pass --binary to ``git diff-tree`` to enable generation
734                         of binary patches
735           --diff-opt    options after the branch name (and an optional ``--``)
736                         are passed directly to ``git diff-tree``
738         In order to pass a sole explicit ``-w`` through to ``git diff-tree`` it
739         must be separated from the ``tg`` options by an explicit ``--``.
740         Or it can be spelled as ``--ignore-all-space`` to distinguuish it from
741         ``tg``'s ``-w`` option.
743         If additional non-``tg`` options are passed through to
744         ``git diff-tree`` (other than ``--binary`` which is fully supported)
745         the resulting ``tg patch`` output may not be appliable.
747 tg mail
748 ~~~~~~~
749         Send a patch from the current or specified topic branch as
750         email(s).
752         Takes the patch given on the command line and emails it out.
753         Destination addresses such as To, Cc and Bcc are taken from the
754         patch header.
756         Since it actually boils down to ``git send-email``, please refer
757         to the documentation for that for details on how to setup email
758         for git.  You can pass arbitrary options to this command through
759         the ``-s`` parameter, but you must double-quote everything.  The
760         ``-r`` parameter with a msgid can be used to generate in-reply-to
761         and reference headers to an earlier mail.
763         WARNING: be careful when using this command.  It easily sends
764         out several mails.  You might want to run::
766                 git config sendemail.confirm always
768         to let ``git send-email`` ask for confirmation before sending any
769         mail.
771         Options:
772           -i            base patch generation on index instead of branch
773           -w            base patch generation on working tree instead of branch
775         | TODO: ``tg mail patchfile`` to mail an already exported patch
776         | TODO: mailing patch series
777         | TODO: specifying additional options and addresses on command line
779 tg remote
780 ~~~~~~~~~
781         Register the given remote as TopGit-controlled. This will create
782         the namespace for the remote branch bases and teach ``git fetch``
783         to operate on them. However, from TopGit 0.8 onwards you need to
784         use ``tg push``, or ``git push --mirror``, for pushing
785         TopGit-controlled branches.
787         ``tg remote`` takes an optional remote name argument, and an
788         optional ``--populate`` switch.  Use ``--populate`` for your
789         origin-style remotes: it will seed the local topic branch system
790         based on the remote topic branches.  ``--populate`` will also make
791         ``tg remote`` automatically fetch the remote, and ``tg update`` look
792         at branches of this remote for updates by default.
794         Using ``--populate`` with a remote name causes the ``topgit.remote``
795         git configuration variable to be set to the given remote name.
797 tg summary
798 ~~~~~~~~~~
799         Show overview of all TopGit-tracked topic branches and their
800         up-to-date status.  With a branch name limit output to that branch.
801         Using ``--deps-only`` or ``--rdeps`` changes the default from all
802         branches to just the current ``HEAD`` branch but using ``--all`` as
803         the branch name will show results for all branches instead of ``HEAD``.
805                 ``>``
806                         marks the current topic branch
808                 ``0``
809                         indicates that it introduces no changes of its own
811                 ``l``/``r``
812                         indicates respectively whether it is local-only
813                         or has a remote mate
815                 ``L``/``R``
816                         indicates respectively if it is ahead or out-of-date
817                         with respect to its remote mate
819                 ``D``
820                         indicates that it is out-of-date with respect to its
821                         dependencies
823                 ``!``
824                         indicates that it has missing dependencies [even if
825                         they are recursive ones]
827                 ``B``
828                         indicates that it is out-of-date with respect to
829                         its base
831         This can take a longish time to accurately determine all the
832         relevant information about each branch; you can pass ``-t`` (or ``-l``
833         or ``--list``) to get just a terse list of topic branch names quickly.
835         Passing ``--heads`` shows independent topic branch names and when
836         combined with ``--rdeps`` behaves as though ``--rdeps`` were run with
837         the output of ``--heads``.
839         Using ``--heads-only`` behaves as though the output of ``--heads`` was
840         passed as the list of branches along with ``--without-deps``.
842         Alternatively, you can pass ``--graphviz`` to get a dot-suitable output
843         for drawing a dependency graph between the topic branches.
845         You can also use the ``--sort`` option to sort the branches using
846         a topological sort.  This is especially useful if each
847         TopGit-tracked topic branch depends on a single parent branch,
848         since it will then print the branches in the dependency order.
849         In more complex scenarios, a text graph view would be much more
850         useful, but that has not yet been implemented.
852         The ``--deps`` option outputs dependency information between
853         branches in a machine-readable format.  Feed this to ``tsort`` to
854         get the output from --sort.
856         The ``--deps-only`` option outputs a sorted list of the unique branch
857         names given on the command line plus all of their recursive
858         dependencies (subject to ``--exclude`` of course).  When
859         ``--deps-only`` is given the default is to just display information for
860         ``HEAD``, but that can be changed by using ``--all`` as the branch
861         name.  Each branch name will appear only once in the output no matter
862         how many times it's visited while tracing the dependency graph or how
863         many branch names are given on the command line to process.
865         The ``--rdeps`` option outputs dependency information in an indented
866         text format that clearly shows all the dependencies and their
867         relationships to one another.  When ``--rdeps`` is given the default is
868         to just display information for ``HEAD``, but that can be changed by
869         using ``--all`` as the branch name or by adding the ``--heads`` option.
870         Note that ``tg summary --rdeps --heads`` can be particularly helpful in
871         seeing all the TopGit-controlled branches in the repository and their
872         relationships to one another.
874         Adding ``--with-deps`` replaces the given list of branches (which will
875         default to ``HEAD`` if none are given) with the result of running
876         ``tg summary --deps-only --tgish`` on the list of branches.  This can
877         be helpful in limiting ``tg summary`` output to only the list of given
878         branches and their dependencies when many TopGit-controlled branches
879         are present in the repository.  When it would be allowed,
880         ``--with-deps`` is now the default.  Use ``--without-deps`` to switch
881         back to the old behavior.
883         With ``--exclude branch``, branch can be excluded from the output
884         meaning it will be skipped and its name will be omitted from any
885         dependency output.  The ``--exclude`` option may be repeated to omit
886         more than one branch from the output.  Limiting the output to a single
887         branch that has been excluded will result in no output at all.
889         The ``--tgish-only`` option behaves as though any non-TopGit-controlled
890         dependencies encountered during processing had been listed after an
891         ``--exclude`` option.
893         Note that the branch name can be specified as ``HEAD`` or ``@`` as a
894         shortcut for the TopGit-controlled branch that ``HEAD`` is a
895         symbolic ref to.  The ``tg summary @`` command can be quite useful.
897         Options:
898           -i            Use TopGit metadata from the index instead of the branch
899           -w            Use TopGit metadata from the working tree instead of the branch
902 tg checkout
903 ~~~~~~~~~~~
904         Switch to a topic branch.  You can use ``git checkout <branch>``
905         to get the same effect, but this command helps you navigate
906         the dependency graph, or allows you to match the topic branch
907         name using a regular expression, so it can be more convenient.
909         There following subcommands are available:
911             ``tg checkout push``
912                                 Check out a branch that directly
913                                 depends on your current branch.
915             ``tg checkout pop``
916                                 Check out a branch that this branch
917                                 directly depends on.
919             ``tg checkout [goto] [--] <pattern>``
920                                 Check out a topic branch that
921                                 matches ``<pattern>``.  ``<pattern>``
922                                 is used as a sed pattern to filter
923                                 all the topic branches.  Both ``goto`` and
924                                 ``--`` may be omitted provided ``<pattern>``
925                                 is not ``push``, ``pop``, ``-a``, ``--all``,
926                                 ``goto``, ``..``, ``--``, ``next``, ``child``,
927                                 ``prev``, ``parent``, ``-h`` or ``--help``.
929             ``tg checkout next``
930                                 An alias for ``push``.
932             ``tg checkout child``
933                                 An alias for ``push``.
935             ``tg checkout``
936                                 An alias for ``push``.
938             ``tg checkout prev``
939                                 An alias for ``pop``.
941             ``tg checkout parent``
942                                 An alias for ``pop``.
944             ``tg checkout ..``
945                                 An alias for ``pop``.
947         If any of the above commands can find more than one possible
948         branch to switch to, you will be presented with the matches
949         and asked to select one of them.
951         The ``<pattern>`` of ``tg checkout goto`` is optional.  If you don't
952         supply it, all the available topic branches are listed and you
953         can select one of them.
955         Normally, the ``push`` and ``pop`` commands moves one step in
956         the dependency graph of the topic branches.  The ``-a`` option
957         causes them (and their aliases) to move as far as possible.
958         That is, ``tg checkout push -a`` moves to a topic branch that
959         depends (directly or indirectly) on the current branch and
960         that no other branch depends on.  ``tg checkout pop -a``
961         moves to a regular branch that the current topic branch
962         depends on (directly or indirectly).  If there is more than
963         one possibility, you will be prompted for your selection.
965 tg export
966 ~~~~~~~~~
967         Export a tidied-up history of the current topic branch and its
968         dependencies, suitable for feeding upstream.  Each topic branch
969         corresponds to a single commit or patch in the cleaned up
970         history (corresponding basically exactly to ``tg patch`` output
971         for the topic branch).
973         The command has three possible outputs now -- either a Git branch
974         with the collapsed history, a Git branch with a linearized
975         history, or a quilt series in new directory.
977         In the case where you are producing collapsed history in a new
978         branch, you can use this collapsed structure either for
979         providing a pull source for upstream, or for further
980         linearization e.g. for creation of a quilt series using git log::
982                 git log --pretty=email -p --topo-order origin..exported
984         To better understand the function of ``tg export``, consider this
985         dependency structure::
987          origin/master - t/foo/blue - t/foo/red - master
988                       `- t/bar/good <,----------'
989                       `- t/baz      ------------'
991         (where each of the branches may have a hefty history). Then::
993          master$ tg export for-linus
995         will create this commit structure on the branch ``for-linus``::
997          origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
998                       `- t/bar/good <,-------------------'/
999                       `- t/baz      ---------------------'
1001         In this mode, ``tg export`` works on the current topic branch, and
1002         can be called either without an option (in that case,
1003         ``--collapse`` is assumed), or with the ``--collapse`` option, and
1004         with one mandatory argument: the name of the branch where the
1005         exported result will be stored.
1007         When using the linearize mode::
1009          master$ tg export --linearize for-linus
1011         you get a linear history respecting the dependencies of your
1012         patches in a new branch ``for-linus``.  The result should be more
1013         or less the same as using quilt mode and then reimporting it
1014         into a Git branch.  (More or less because the topological order
1015         can usually be extended in more than one way into a total order,
1016         and the two methods may choose different ones.)  The result
1017         might be more appropriate for merging upstream, as it contains
1018         fewer merges.
1020         Note that you might get conflicts during linearization because
1021         the patches are reordered to get a linear history.  If linearization
1022         would produce conflicts then using ``--quilt`` will also likely result
1023         in conflicts when the exported quilt series is applied.  Since the
1024         ``--quilt`` mode simply runs a series of ``tg patch`` commands to
1025         generate the patches in the exported quilt series and those patches
1026         will end up being applied linearly, the same conflicts that would be
1027         produced by the ``--linearize`` option will then occur at that time.
1029         To avoid conflicts produced by ``--linearize`` (or by applying the
1030         ``--quilt`` output), use the default ``--collapse`` mode and then use
1031         ``tg rebase`` (or ``git rebase -m`` directly) on the collapsed branch
1032         (with a suitable <upstream>) followed by ``git format-patch`` on the
1033         rebased result to produce a conflict-free patch set.  A suitable
1034         upstream may be determined with the ``tg info --leaves`` command (if
1035         it outputs more than one line, linearization will be problematic).
1037         You have enabled ``git rerere`` haven't you?
1039         When using the quilt mode::
1041          master$ tg export --quilt for-linus
1043         would create the following directory ``for-linus``::
1045          for-linus/t/foo/blue.diff
1046          for-linus/t/foo/red.diff
1047          for-linus/t/bar/good.diff
1048          for-linus/t/baz.diff
1049          for-linus/series:
1050                 t/foo/blue.diff -p1
1051                 t/bar/good.diff -p1
1052                 t/foo/red.diff -p1
1053                 t/baz.diff -p1
1055         With ``--quilt``, you can also pass the ``-b`` parameter followed
1056         by a comma-separated explicit list of branches to export, or
1057         the ``--all`` parameter (which can be shortened to ``-a``) to
1058         export them all.  The ``--binary`` option enables producing Git
1059         binary patches.  These options are currently only supported
1060         with ``--quilt``.
1062         In ``--quilt`` mode the patches are named like the originating
1063         topgit branch.  So usually they end up in subdirectories of the
1064         output directory.  With the ``--flatten`` option the names are
1065         mangled so that they end up directly in the output dir (slashes
1066         are replaced with underscores).  With the ``--strip[=N]`` option
1067         the first ``N`` subdirectories (all if no ``N`` is given) get
1068         stripped off.  Names are always ``--strip``'d before being
1069         ``--flatten``'d.  With the option ``--numbered`` (which implies
1070         ``--flatten``) the patch names get a number as prefix to allow
1071         getting the order without consulting the series file, which
1072         eases sending out the patches.
1074         | TODO: Make stripping of non-essential headers configurable
1075         | TODO: Make stripping of [PATCH] and other prefixes configurable
1076         | TODO: ``--mbox`` option to export instead as an mbox file
1077         | TODO: support ``--all`` option in other modes of operation
1078         | TODO: For quilt exporting, export the linearized history created in
1079                 a temporary branch--this would allow producing conflict-less
1080                 series
1082 tg import
1083 ~~~~~~~~~
1084         Import commits within the given revision range into TopGit,
1085         creating one topic branch per commit. The dependencies are set
1086         up to form a linear sequence starting on your current branch --
1087         or a branch specified by the ``-d`` parameter, if present.
1089         The branch names are auto-guessed from the commit messages and
1090         prefixed by ``t/`` by default; use ``-p <prefix>`` to specify an
1091         alternative prefix (even an empty one).
1093         Alternatively, you can use the ``-s NAME`` parameter to specify
1094         the name of the target branch; the command will then take one
1095         more argument describing a *single* commit to import.
1097 tg update
1098 ~~~~~~~~~
1099         Update the current, specified or all topic branches with respect
1100         to changes in the branches they depend on and remote branches.
1101         This is performed in two phases -- first, changes within the
1102         dependencies are merged to the base, then the base is merged
1103         into the topic branch.  The output will guide you on what to do
1104         next in case of conflicts.
1106         You have enabled ``git rerere`` haven't you?
1108         When ``-a`` (or ``--all``) is specifed, updates all topic branches
1109         matched by ``<pattern>``'s (see ``git-for-each-ref(1)`` for details),
1110         or all if no ``<pattern>`` is given.  Any topic branches with missing
1111         dependencies will be skipped entirely unless ``--skip-missing`` is
1112         specified.
1114         When ``--skip-missing`` is specifed, an attempt is made to update topic
1115         branches with missing dependencies by skipping only the dependencies
1116         that are missing.  Caveat utilitor.
1118         When ``--stash`` is specified (or the ``topgit.autostash`` config
1119         value is set to ``true``), a ref stash will be automatically created
1120         just before beginning updates if any are needed.  The ``--no-stash``
1121         option may be used to disable a ``topgit.autostash=true`` setting.
1122         See the ``tg tag`` ``--stash`` option for details.
1124         After the update, if a single topic branch was specified, it is
1125         left as the current one; if ``-a`` was specified, it returns to
1126         the branch which was current at the beginning.
1128         If your dependencies are not up-to-date, ``tg update`` will first
1129         recurse into them and update them.
1131         If a remote branch update brings in dependencies on branches
1132         that are not yet instantiated locally, you can either bring in
1133         all the new branches from the remote using ``tg remote
1134         --populate``, or only pick out the missing ones using ``tg create
1135         -r`` (``tg summary`` will point out branches with incomplete
1136         dependencies by showing an ``!`` next to them).
1138         | TODO: ``tg update -a -c`` to autoremove (clean) up-to-date branches
1140 tg push
1141 ~~~~~~~
1142         If ``-a`` or ``--all`` was specified, pushes all non-annihilated
1143         TopGit-controlled topic branches, to a remote repository.
1144         Otherwise, pushes the specified topic branches -- or the
1145         current branch, if you don't specify which.  By default, the
1146         remote gets all the dependencies (both TopGit-controlled and
1147         non-TopGit-controlled) and bases pushed to it too.  If
1148         ``--tgish-only`` was specified, only TopGit-controlled
1149         dependencies will be pushed, and if ``--no-deps`` was specified,
1150         no dependencies at all will be pushed.
1152         The ``--dry-run`` and ``--force`` options are passed directly to
1153         ``git push`` if given.
1155         The remote may be specified with the ``-r`` option. If no remote
1156         was specified, the configured default TopGit remote will be
1157         used.
1159 tg base
1160 ~~~~~~~
1161         Prints the base commit of each of the named topic branches, or
1162         the current branch if no branches are named.  Prints an error
1163         message and exits with exit code 1 if the named branch is not
1164         a TopGit branch.
1166 tg log
1167 ~~~~~~
1168         Prints the git log of the named topgit branch -- or the current
1169         branch, if you don't specify a name.
1171         This is really just a convenient shortcut for:
1173             ``git log --first-parent --no-merges $(tg base <name>)..<name>``
1175         where ``<name>`` is the name of the TopGit topic branch (or omitted
1176         for the current branch).
1178         NOTE: if you have merged changes from a different repository, this
1179         command might not list all interesting commits.
1181 tg tag
1182 ~~~~~~
1183         Creates a TopGit annotated/signed tag or lists the reflog of one.
1185         A TopGit annotated tag records the current state of one or more TopGit
1186         branches and their dependencies and may be used to revert to the tagged
1187         state at any point in the future.
1189         When reflogs are enabled (the default in a non-bare repository) and
1190         combined with the ``--force`` option a single tag name may be used as a
1191         sort of TopGit branch state stash.  The special branch name ``--all``
1192         may be used to tag the state of all current TopGit branches to
1193         facilitate this function and has the side-effect of suppressing the
1194         out-of-date check allowing out-of-date branches to be included.
1196         As a special feature, ``--stash`` may be used as the tag name in which
1197         case ``--all`` is implied if no branch name is listed (instead of the
1198         normal default of ``HEAD``), ``--force`` and ``--no-edit`` (use
1199         ``--edit`` to change that) are automatically activated and the tag will
1200         be saved to ``refs/tgstash`` instead of ``refs/tags/<tagname>``.
1201         The ``--stash`` tag name may also be used with the ``-g``/``--reflog``
1202         option.
1204         The mostly undocumented option ``--allow-outdated`` will bypass the
1205         out-of-date check and is implied when ``--stash`` or ``--all`` is used.
1207         A TopGit annotated/signed tag is simply a Git annotated/signed tag with
1208         a "TOPGIT REFS" section appended to the end of the tag message (and
1209         preceding the signature for signed tags).  PEM-style begin and end
1210         lines surround one line per ref where the format of each line is
1211         full-hash SP ref-name.  A line will be included for each branch given
1212         on the command line and each ref they depend on either directly or
1213         indirectly.
1215         If more than one TopGit branch is given on the command line, a new
1216         commit will be created that has an empty tree and all of the given
1217         TopGit branches as parents and that commit will be tagged.  If a single
1218         TopGit branch is given, then it will be tagged.  If the ``--tree``
1219         option is used then it will be used instead of an empty tree (a new
1220         commit will be created if necessary to guarantee the specified tree is
1221         what's in the commit the newly created tag refers to).  The argument to
1222         the ``--tree`` option may be any valid treeish.
1224         All the options for creating a tag serve the same purpose as their Git
1225         equivalents except for two.  The ``--refs`` option suppresses tag
1226         creation entirely and emits the "TOPGIT REFS" section that would have
1227         been included with the tag.  If the ``--no-edit`` option is given and
1228         no message is supplied (via the ``-m`` or ``-F`` option) then the
1229         default message created by TopGit will be used without running the
1230         editor.
1232         With ``-g`` or ``--reflog`` show the reflog for a tag.  With the
1233         ``--reflog-message`` option the message from the reflog is shown.
1234         With the ``--commit-message`` option the first line of the tag's
1235         message (if the object is a tag) or the commit message (if the object
1236         is a commit) falling back to the reflog message for tree and blob
1237         objects is shown.  The default is ``--reflog-message`` unless the
1238         ``--stash`` (``refs/tgstash``) is being shown in which case the default
1239         is then ``--commit-message``.  Just add either option explicitly to
1240         override the default.
1242         When showing reflogs, non-tag entries are annotated with their type
1243         unless ``--no-type`` is given.
1245         TopGit tags are created with a reflog if core.logallrefupdates is
1246         enabled (the default for non-bare repositories).  Unfortunately Git
1247         is incapable of showing an annotated/signed tag's reflog
1248         (using git log -g) as it will first resolve the tag before checking to
1249         see if it has a reflog.  Git can, however, show reflogs for lightweight
1250         tags (using git log -g) just fine but that's not helpful here.  Use
1251         ``tg tag`` with the ``-g`` or ``--reflog`` option to see the reflog for
1252         an actual tag object.  This also works on non-TopGit annotated/signed
1253         tags as well provided they have a reflog.
1255         The number of entries shown may be limited with the ``-n`` option.  If
1256         the tagname is omitted then ``--stash`` is assumed.
1258         The ``--delete`` option is a convenience option that runs the
1259         ``git update-ref -d`` command on the specified tag removing it and its
1260         reflog (if it has one).
1262         The ``--clear`` option clears all but the most recent (the ``@{0}``)
1263         reflog entries from the reflog for the specified tag.  It's equivalent
1264         to dropping all the higher numbered reflog entries.
1266         The ``--drop`` option drops the specified reflog entry and requires the
1267         given tagname to have an ``@{n}`` suffix where ``n`` is the reflog
1268         entry number to be dropped.   This is really just a convenience option
1269         that runs the appropriate ``git reflog delete`` command.
1271         Note that when combined with ``tg revert``, a tag created by ``tg tag``
1272         can be used to transfer TopGit branches.  Simply create the tag, push
1273         it somewhere and then have the recipient run ``tg revert`` to recreate
1274         the TopGit branches.  This may be helpful in situations where it's not
1275         feasible to push all the refs corresponding to the TopGit-controlled
1276         branches and their top-bases.
1278 tg rebase
1279 ~~~~~~~~~
1280         Provides a ``git rebase`` rerere auto continue function.  It may be
1281         used as a drop-in replacement front-end for ``git rebase -m`` that
1282         automatically continues the rebase when ``git rerere`` information is
1283         sufficient to resolve all conflicts.
1285         You have enabled ``git rerere`` haven't you?
1287         If the ``-m`` or ``--merge`` option is not present then ``tg rebase``
1288         will complain and not do anything.
1290         When ``git rerere`` is enabled, previously resolved conflicts are
1291         remembered and can be automatically staged (see ``rerere.autoUpdate``).
1293         However, even with auto staging, ``git rebase`` still stops and
1294         requires an explicit ``git rebase --continue`` to keep going.
1296         In the case where ``git rebase -m`` is being used to flatten history
1297         (such as after a ``tg export --collapse`` prior to a
1298         ``git format-patch``), there's a good chance all conflicts have already
1299         been resolved during normal merge maintenance operations so there's no
1300         reason ``git rebase`` could not automatically continue, but there's no
1301         option to make it do so.
1303         The ``tg rebase`` command provides a ``git rebase --auto-continue``
1304         function.
1306         All the same rebase options can be used (they are simply passed through
1307         to Git unchanged).  However, the ``rerere.autoUpdate`` option is
1308         automatically temporarily enabled while running ``git rebase`` and
1309         should ``git rebase`` stop asking one to resolve and continue, but all
1310         conflicts have already been resolved and staged using rerere
1311         information, then ``git rebase --continue`` will be automatically run.
1313 tg revert
1314 ~~~~~~~~~
1315         Provides the ability to revert one or more TopGit branches and their
1316         dependencies to a previous state contained within a tag created using
1317         the ``tg tag`` command.  In addition to the actual revert mode
1318         operation a list mode operation is also provided to examine a tag's ref
1319         contents.
1321         The default mode (``-l`` or ``--list``) shows the state of one or more
1322         of the refs/branches stored in the tag data.  When no refs are given on
1323         the command line, all refs in the tag data are shown.  With the special
1324         ref name ``--heads`` then the indepedent heads contained in the tag
1325         data are shown.  The ``--deps`` option shows the specified refs and all
1326         of their dependencies in a single list with no duplicates.  The
1327         ``--rdeps`` option shows a display similar to ``tg summary --rdeps``
1328         for each ref or all independent heads if no ref is given on the command
1329         line.  The standard ``--no-short``, ``--short=n`` etc. options may be
1330         used to override the default ``--short`` output.  With ``--hash`` (or
1331         ``--hash-only``) show only the hash in ``--list`` mode in which case
1332         the default is ``--no-short``.   The ``--hash`` option can be used much
1333         like the ``git rev-parse --verify`` command to extract a specific hash
1334         value out of a TopGit tag.
1336         The revert mode has three submodes, dry-run mode (``-n`` or
1337         ``--dry-run``), force mode (``-f`` or ``--force``) and interactive mode
1338         (``-i`` or ``--interactive``).  If ``--dry-run`` (or ``-n``) is given
1339         no ref updates will actually be performed but what would have been
1340         updated is shown instead.  If ``--interactive`` (or ``-i``) is given
1341         then the editor is invoked on an instruction sheet allowing manual
1342         selection of the refs to be updated before proceeding.  Since revert is
1343         potentially a destructive operation, at least one of the submodes must
1344         be specified explicitly.  If no refs are listed on the command line
1345         then all refs in the tag data are reverted.  Otherwise the listed refs
1346         and all of their dependencies (unless ``--no-deps`` is given) are
1347         reverted.  Unless ``--no-stash`` is given a new stash will be created
1348         using ``tg tag --stash`` (except, of course, in dry-run mode) just
1349         before actually performing the updates to facilitate recovery from
1350         accidents.
1352         Both modes accept fully-qualified (i.e. starts with ``refs/``) ref
1353         names as well as unqualified names (which will be assumed to be located
1354         under ``refs/heads/``).  In revert mode a tgish ref will always have
1355         both its ``refs/heads/`` and ``refs/top-bases/`` values included no
1356         matter how it's listed unless ``--no-deps`` is given and the ref is
1357         fully qualified (i.e. starts with ``refs/``) or one or the other of its
1358         values was removed from the instruction sheet in interactive mode.  In
1359         list mode a tgish ref will always have both its ``refs/heads/`` and
1360         ``refs/top-bases/`` values included only when using the ``--deps`` or
1361         ``--rdeps`` options.
1363         The ``--tgish-only`` option excludes non-tgish refs (i.e. refs that do
1364         not have a ``refs/heads/<name>``, ``refs/top-bases/<name>`` pair).
1366         The ``--exclude`` option (which can be repeated) excludes specific
1367         refs.  If the name given to ``--exclude`` is not fully-qualified (i.e.
1368         starts with ``refs/``) then it will exclude both members of a tgish ref
1369         pair.
1371         The ``--quiet`` (or ``-q``) option may be used in revert mode to
1372         suppress non-dry-run ref change status messages.
1374         The special tag name ``--stash`` (as well as with ``@{n}`` suffixes)
1375         can be used to refer to ``refs/tgstash``.
1377         The ``tg revert`` command supports tags of tags that contains TopGit
1378         refs.  So, for example, if you do this::
1380                 tg tag newtag --all
1381                 git tag -f -a -m "tag the tag" newtag newtag
1383         Then ``newtag`` will be a tag of a tag containing a ``TOPGIT REFS``
1384         section.  ``tg revert`` knows how to dereference the outermost
1385         tag to get to the next (and the next etc.) tag to find the
1386         ``TOPGIT REFS`` section so after the above sequence, the tag ``newtag``
1387         can still be used successfully with ``tg revert``.
1389         NOTE:  If HEAD points to a ref that is updated by a revert operation
1390         then NO WARNING whatsoever will be issued, but the index and working
1391         tree will always be left completely untouched (and the reflog for
1392         the pointed-to ref can always be used to find the previous value).
1394 tg prev
1395 ~~~~~~~
1396         Outputs the direct dependencies for the current or named branch.
1398         Options:
1399           -i            show dependencies based on index instead of branch
1400           -w            show dependencies based on working tree instead of branch
1402 tg next
1403 ~~~~~~~
1404         Outputs all branches which directly depend on the current or
1405         named branch.
1407         Options:
1408           -i            show dependencies based on index instead of branch
1409           -w            show dependencies based on working tree instead of branch
1411 tg migrate-bases
1412 ~~~~~~~~~~~~~~~~
1413         Transition top-bases from old location to new location.
1415         Beginning with TopGit release 0.19.4, TopGit has the ability to store
1416         the top-bases refs in either the old ``ref/top-bases/...`` location or
1417         the new ``refs/heads/{top-bases}/...`` location.  Starting with TopGit
1418         release 0.20.0, the default is the new location.
1420         By storing the top-bases under heads, Git is less likely to complain
1421         when manipulating them, hosting providers are more likely to provide
1422         access to them and Git prevents them from pointing at anything other
1423         than a commit object.  All in all a win for everyone.
1425         TopGit attempts to automatically detect whether the new or old location
1426         is being used for the top-bases and just do the right thing.  However,
1427         by explicitly setting the config value ``topgit.top-bases`` to either
1428         ``refs`` for the old location or ``heads`` for the new location the
1429         auto-detection can be bypassed.  If no top-bases refs are present in
1430         the repository the default prior to TopGit release 0.20.0 is to use the
1431         old location but starting with TopGit release 0.20.0 the default is to
1432         use the new location.
1434         The ``tg migrate-bases`` command may be used to migrate top-bases refs
1435         from the old location to the new location (or, by using the
1436         undocumented ``--reverse`` option, vice versa).
1438         With few exceptions (``tg create -r`` and ``tg revert``), all top-bases
1439         refs (both local *and* remote refs) are expected to be stored in the
1440         same location (either new or old).  A repository's current location for
1441         storing top-bases refs may be shown with the ``tg --top-bases`` command.
1443 TODO: tg rename
1444 ~~~~~~~~~~~~~~~
1446 IMPLEMENTATION
1447 --------------
1449 TopGit stores all the topic branches in the regular ``refs/heads/``
1450 namespace (so we recommend distinguishing them with the ``t/`` prefix).
1451 Apart from that, TopGit also maintains a set of auxiliary refs in
1452 ``refs/top-*``.  Currently, only ``refs/top-bases/`` is used, containing the
1453 current *base* of the given topic branch -- this is basically a merge of
1454 all the branches the topic branch depends on; it is updated during ``tg
1455 update`` and then merged to the topic branch, and it is the base of a
1456 patch generated from the topic branch by ``tg patch``.
1458 All the metadata is tracked within the source tree and history of the
1459 topic branch itself, in ``.top*`` files; these files are kept isolated
1460 within the topic branches during TopGit-controlled merges and are of
1461 course omitted during ``tg patch``.  The state of these files in base
1462 commits is undefined; look at them only in the topic branches
1463 themselves.  Currently, two files are defined:
1465         ``.topmsg``:
1466             Contains the description of the topic branch in a
1467             mail-like format, plus the author information, whatever
1468             Cc headers you choose or the post-three-dashes message.
1469             When mailing out your patch, basically only a few extra
1470             mail headers are inserted and then the patch itself is
1471             appended.  Thus, as your patches evolve, you can record
1472             nuances like whether the particular patch should have
1473             To-list / Cc-maintainer or vice-versa and similar
1474             nuances, if your project is into that.  ``From`` is
1475             prefilled from your current ``GIT_AUTHOR_IDENT``; other
1476             headers can be prefilled from various optional
1477             ``topgit.*`` git config options.
1479         ``.topdeps``:
1480             Contains the one-per-line list of branches this branch
1481             depends on, pre-seeded by ``tg create``. A (continuously
1482             updated) merge of these branches will be the *base* of
1483             your topic branch.
1485 IMPORTANT: DO NOT EDIT ``.topdeps`` MANUALLY!!! If you do so, you need to
1486 know exactly what you are doing, since this file must stay in sync with
1487 the Git history information, otherwise very bad things will happen.
1489 TopGit also automagically installs a bunch of custom commit-related
1490 hooks that will verify whether you are committing the ``.top*`` files in a
1491 sane state. It will add the hooks to separate files within the ``hooks/``
1492 subdirectory, and merely insert calls to them to the appropriate hooks
1493 and make them executable (but will make sure the original hook's code is
1494 not called if the hook was not executable beforehand).
1496 Another automagically installed piece is a ``.git/info/attributes``
1497 specifier for an ``ours`` merge strategy for the files ``.topmsg`` and
1498 ``.topdeps``, and the (intuitive) ``ours`` merge strategy definition in
1499 ``.git/config``.
1502 REMOTE HANDLING
1503 ---------------
1505 There are two remaining issues with accessing topic branches in remote
1506 repositories:
1508         (i) Referring to remote topic branches from your local repository
1509         (ii) Developing some of the remote topic branches locally
1511 There are two somewhat contradictory design considerations here:
1513         (a) Hacking on multiple independent TopGit remotes in a single
1514             repository
1515         (b) Having a self-contained topic system in local refs space
1517 To us, (a) does not appear to be very convincing, while (b) is quite
1518 desirable for ``git-log topic`` etc. working, and increased conceptual
1519 simplicity.
1521 Thus, we choose to instantiate all the topic branches of given remote
1522 locally; this is performed by ``tg remote --populate``. ``tg update``
1523 will also check if a branch can be updated from its corresponding remote
1524 branch.  The logic needs to be somewhat involved if we are to "do the
1525 right thing".  First, we update the base, handling the remote branch as
1526 if it was the first dependency; thus, conflict resolutions made in the
1527 remote branch will be carried over to our local base automagically.
1528 Then, the base is merged into the remote branch and the result is merged
1529 to the local branch -- again, to carry over remote conflict resolutions.
1530 In the future, this order might be adjustable on a per-update basis, in
1531 case local changes happen to be diverging more than the remote ones.
1532 (See the details in `The Update Process`_ for more in depth coverage.)
1534 All commands by default refer to the remote that ``tg remote --populate``
1535 was called on the last time (stored in the ``topgit.remote`` git
1536 configuration variable). You can manually run any command with a
1537 different base remote by passing ``-r REMOTE`` *before* the subcommand
1538 name.
1541 TECHNICAL
1542 ---------
1544 A familiarity with the terms in the GLOSSARY_ is helpful for understanding the
1545 content of this sections.  See also the IMPLEMENTATION_ section.
1547 The Update Process
1548 ~~~~~~~~~~~~~~~~~~
1550 When a branch is "updated" using the ``tg update`` command the following steps
1551 are taken:
1553         1) The branch and all of its dependencies (and theirs recursively)
1554            are checked to see which ones are *out-of-date*.  See glossary_.
1556         2) Each of the branch's direct dependencies (i.e. they are listed in
1557            the branch's ``.topdeps`` file) which is out of date is updated
1558            before proceeding (yup, this is a recursive process).
1560         3) Each of the branch's direct dependencies (i.e. they are listed in
1561            the branch's ``.topdes`` file) that was updated in the previous
1562            step is now merged into the branch's corresponding base.  If a
1563            remote is involved, and the branch's corresponding base does NOT
1564            contain the remote branch's corresponding base that remote base is
1565            also merged into the branch's base at this time as well (it will be
1566            the first item merged into the branch's base).
1568         4) If the branch has a corresponding remote branch and the branch
1569            does not already contain it, it's merged into the branch's base
1570            (which was possibly already updated in step (3) to contain the
1571            remote branch's base but not the remote branch itself) on a detached
1572            HEAD.  Yup, this step can be a bit confusing and no, the updated
1573            base from step (3) has not yet been merged into the branch itself
1574            yet either.  If there is no remote branch this step does not apply.
1575            Using a detached HEAD allows the remote branch to be merged into the
1576            contents of the base without actually perturbing the base's ref.
1578         5) If there is a remote branch present then use the result of step (4)
1579            otherwise use the branch's base and merge that into the branch
1580            itself.
1582 That's it!  Simple, right? ;)
1584 Unless the auto stash option has been disabled (see `no undo`_, `tg update`_
1585 and `tg tag`_), a copy of all the old refs values will be stashed away
1586 immediately after step (1) before starting step (2), but only if anything is
1587 actually found to be out-of-date.
1590 GLOSSARY
1591 --------
1593         .topmsg
1594                 Version-controlled file stored at the root level of each
1595                 TopGit branch that contains the patch header for a TopGit
1596                 branch.  See also IMPLEMENTATION_;
1598         .topdeps
1599                 Version-controlled file stored at the root level of each
1600                 TopGit branch that lists the branch's dependencies one per
1601                 line omitting the leading ``refs/heads/`` part.  See also
1602                 IMPLEMENTATION_;
1604         branch containment
1605                 Given two Git commit identifiers (e.g. hashes) C1 and C2,
1606                 commit C1 "contains" commit C2 if either they are the same
1607                 commit or C2 can be reached from C1 by following one or more
1608                 parent links from C1 (perhaps via one or more intermediate
1609                 commits along the way).  In other words, if C1 contains C2
1610                 then C2 is an ancestor of C1 or conversely C1 is a descendant
1611                 of C2.  Since a TopGit branch name is also the name of a Git
1612                 branch (something located under the ``refs/heads`` Git
1613                 namespace) and similarly for a TopGit base, they can both be
1614                 resolved to a Git commit identifier and then participate in
1615                 a branch containment test.  An easy mnemonic for this is
1616                 "children contain the genes of their parents."
1618         contains
1619                 See branch containment.
1621         TopGit
1622                 Excellent system for managing a history of changes to one
1623                 or more possibly interrelated patches.
1625         TopGit branch
1626                 A Git branch that has an associated TopGit base.  Conceptually
1627                 it represents a single patch that is the difference between
1628                 the associated TopGit base and the TopGit branch.  In other
1629                 words ``git diff-tree <TopGit base> <TopGit branch>`` except
1630                 that any ``.topdeps`` and/or ``.topmsg`` files are excluded
1631                 from the result and the contents of the ``.topmsg`` file from
1632                 the TopGit branch is prefixed to the result.
1634         TopGit base
1635                 A Git branch that records the base upon which a TopGit branch's
1636                 single conceptual "patch" is built.  The name of the Git branch
1637                 is derived from the TopGit branch name by stripping off the
1638                 leading ``refs/heads/`` and appending the correct prefix where
1639                 all TopGit bases are stored (typically either
1640                 ``refs/top-bases/`` or ``refs/heads/{top-bases}/`` -- the
1641                 prefix for any given repository can be shown by using the
1642                 ``tg --top-bases`` command and updated using the
1643                 ``tg migrate-bases`` command).
1645                 All of a TopGit branch's dependencies are merged into the
1646                 corresponding TopGit base during a ``tg update`` of a branch.
1648         base
1649                 See TopGit base.
1651         TopGit ``[PATCH]`` branch
1652                 A TopGit branch whose subject starts with ``[PATCH]``.  By
1653                 convention these TopGit branches contain a single patch
1654                 (equivalent to a single patch file) and have at least one
1655                 dependency (i.e. their ``.topdeps`` files are never empty).
1657         TopGit ``[BASE]`` branch
1658                 A TopGit branch whose subject starts with ``[BASE]``.  By
1659                 convention these TopGit branches do not actually contain
1660                 any changes and their ``.topdeps`` files are empty.  They
1661                 are used to control a base dependency that another set of
1662                 branches depends on.
1664         TopGit ``[STAGE]`` branch
1665                 A TopGit branch whose subject starts with ``[STAGE]``.  By
1666                 convention these TopGit branches do not actually contain any
1667                 changes of their own but do have one or (typically) more
1668                 dependencies in their ``.topdeps`` file.  These branches are
1669                 used to bring together one or (typically) more independent
1670                 TopGit ``[PATCH]`` branches into a single branch so that
1671                 testing and/or evaluation can be performed on the result.
1673         out-of-date branch
1674                 A TopGit branch is considered to be "out-of-date" when ANY of
1675                 the following are true:
1677                         a) The TopGit branch does NOT contain its
1678                            corresponding base.
1680                         b) The TopGit branch does NOT contain its
1681                            corresponding remote branch (there may not be
1682                            a remote branch in which case this does not apply)
1684                         c) The TopGit branch's base does NOT contain its
1685                            corresponding remote branch's base (there may not be
1686                            a remote branch in which case this does not apply)
1688                         d) Any of the TopGit branches listed in the branch's
1689                            ``.topdeps`` file are NOT contained by the branch.
1690                            (See "branch containment" above.)
1692                         e) Any of the TopGit branches listed in the branch's
1693                            ``.topdeps`` file are out-of-date.
1695                 Note that if a remote branch is present and is NOT out-of-date
1696                 then it will contain its own base and (c) is mostly redundant.
1698         remote TopGit branch
1699                 A Git branch with the same branch name as a TopGit branch
1700                 but living under ``refs/remotes/```<some remote>```/`` instead
1701                 of just ``refs/heads/``.
1703         remote TopGit base
1704                 The TopGit base branch corresponding to a remote TopGit branch,
1705                 which lives under ``refs/remotes/`` somewhere (depending on
1706                 what the output of ``tg --top-bases`` is for that remote).
1709 REFERENCES
1710 ----------
1712 The following references are useful to understand the development of
1713 topgit and its subcommands.
1715 * tg depend:
1716   http://public-inbox.org/git/36ca99e90904091034m4d4d31dct78acb333612e678@mail.gmail.com/T/#u
1719 THIRD-PARTY SOFTWARE
1720 --------------------
1722 The following software understands TopGit branches:
1724 * `magit <http://magit.github.io/>`_ -- a git mode for emacs
1726 IMPORTANT: Magit requires its topgit mode to be enabled first, as
1727 described in its documentation, in the "Activating extensions"
1728 subsection.  If this is not done, it will not push TopGit branches
1729 correctly, so it's important to enable it even if you plan to mostly use
1730 TopGit from the command line.