1 =========================================
2 TopGit -- A different patch queue manager
3 =========================================
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.
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
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).
45 See the file ``INSTALL``.
51 The TopGit git repository can be found at <http://repo.or.cz/topgit/pro>.
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
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
106 (ii) When using TopGit, your history can get a little hairy
107 over time, especially with all the merges rippling through.
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...
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...
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...
139 tg: Sent t/revlist/author-fixed
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...
150 tg: Please commit merge resolution and call: tg update --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.
156 $ tg update --continue
160 ## Update a single topic branch and propagate the changes to
162 $ git checkout t/gitweb/nifty-links
165 $ git checkout t/whatever
167 Topic Branch: t/whatever (1 commit)
168 Subject: [PATCH] Whatever patch
170 Depends: t/revlist/author-fixed t/gitweb/nifty-links
172 t/gitweb/nifty-links (1 commit)
174 tg: Updating base with t/gitweb/nifty-links changes...
176 tg: Please commit merge resolution and call `tg update --continue`
177 tg: (use `tg status` to see more options)
180 $ tg update --continue
181 tg: Updating t/whatever against new base...
183 tg: Please commit merge resolution and call `tg update --continue`
184 tg: (use `tg status` to see more options)
187 $ tg update --continue
189 ## Update a single topic branch and propagate the changes
190 ## further through the dependency chain
191 $ git checkout t/gitweb/pathinfo-action
194 $ git checkout t/whatever
196 Topic Branch: t/whatever (1/2 commits)
197 Subject: [PATCH] Whatever patch
199 Depends: t/revlist/author-fixed t/gitweb/nifty-links
201 t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
203 tg: Recursing to t/gitweb/nifty-links...
204 [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
206 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
207 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
210 $ tg update --continue
211 [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base...
213 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
214 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
217 $ tg update --continue
218 tg: Updating base with t/gitweb/nifty-links changes...
219 tg: Updating t/whatever against new base...
221 ## Clone a TopGit-controlled repository
224 $ tg remote --populate origin
229 ## Add a TopGit remote to a repository and push to it
230 $ git remote add foo URL
234 ## Update from a non-default TopGit remote
243 When using TopGit there are several common conventions used when working with
244 TopGit branches. None of them are enforced, they are only suggestions.
246 There are three typical uses for a TopGit branch:
249 Normal TopGit branches that represent a single patch. These are known
250 as "patch" TopGit branches.
252 Empty TopGit branches with no dependencies (an empty ``.topdeps`` file)
253 that represent a base upon which other "normal" TopGit branches depend.
254 These are known as "base" TopGit branches (not to be confused with
255 the refs/top-bases/... refs).
257 Empty TopGit branches that serve as a staging area to bring together
258 several other TopGit branches into one place so they can be used/tested
259 all together. These are known as "stage" TopGit branches.
261 An "empty" TopGit branch is one that does not have any changes of its own --
262 it may still have dependencies though ("stage" branches do, "base" branches do
263 not). The ``tg summary`` output shows empty branches with a ``0`` in the
264 listing. Normal "patch" branches that have not been annihilated, "base" and
265 "stage" branches fall into this category. (Annihilated branches are normally
266 omitted from the ``tg summary`` output but can be shown if given explicitly as
267 an argument to the ``tg summary`` command. However, the message line will be
268 incorrect since an annihilated branch has no ``.topmsg`` file of its own.)
270 A "patch" branch name typically starts with ``t/`` whereas "base" and "stage"
271 branch names often do not.
273 A "base" branch is created by using the ``--no-deps`` option of ``tg create``
274 which will automatically suggest a "[BASE]" message prefix rather than
275 "[PATCH]". A "stage" branch is created like a normal patch branch except that
276 the only changes that will ever be made to it are typically to add/remove
277 dependencies. Its subject prefix must be manually changed to "[STAGE]" to
280 Since both "base" and "stage" branches typically only have a use for the
281 "Subject:" ilne from their ``.topmsg`` file, they are quite easily created
282 using the ``--topmsg`` option of ``tg create``.
284 Use of "stage" and "base" branches is completely optional. However, without
285 use of a "stage" branch it will be difficult to test multiple independent
286 patches together all at once. A "base" branch is merely a convenience that
287 provides more explicit control over when a common base for a set of patches
288 gets updated as well as providing a branch that shows in ``tg summary`` output
289 and participates in ``tg remote --populate`` setup.
291 When using the ``tg tag`` command to create tags that record the current state
292 of one or more TopGit branches, the tags are often created with a name that
295 One last thing, you have enabled ``git rerere`` haven't you?
301 Beware, there is no "undo" after running a ``tg update``!
303 Well, that's not entirely correct. Since ``tg update`` never discards commits
304 an "undo" operation is technically feasible provided the old values of all the
305 refs that were affected by the ``tg update`` operation can be determined and
306 then they are simply changed back to their previous values.
308 In practice though, it can be extremely tedious and error prone looking through
309 log information to try and determine what the correct previous values were.
310 Although, since TopGit tries to make sure reflogs are enabled for top-bases
311 refs, using Git's ``@{date}`` notation on all the refs dumped out by a
312 ``tg tag --refs foo``, where "foo" is the branch that was updated whose update
313 needs to be undone, may work.
315 Alternatively, ``tg tag --stash`` can be used prior to the update and then
316 ``tg revert`` used after the update to restore the previous state. This
317 assumes, of course, that you remember to run ``tg tag --stash`` first.
319 The ``tg update`` command understands a ``--stash`` option that tells it to
320 automatically run ``tg tag --stash`` before it starts making changes (if
321 everything is up-to-date it won't run the stash command at all).
323 The ``--stash`` option is the default nowadays when running ``tg update``,
324 add the ``--no-stash`` option to turn it off.
326 There is a preference for this. Setting the config value ``topgit.autostash``
327 to ``false`` will implicitly add the ``--no-stash`` option to any ``tg update``
328 command unless an explicit ``--stash`` option is given.
330 If you are likely to ever want to undo a ``tg update``, setting
331 ``topgit.autostash`` to ``false`` is highly discouraged!
333 Note that the tags saved by ``tg tag --stash`` are stored in the
334 ``refs/tgstash`` ref and its reflog. Unfortunately, while Git is happy to
335 maintain the reflog (once it's been enabled which ``tg tag`` guarantees for
336 ``refs/tgstash``), Git is unable to view an annotated/signed tag's reflog!
337 Instead Git dereferences the tag and shows the wrong thing. Use the
338 ``tg tag -g`` command to view the ``refs/tgstash`` reflog instead.
344 No, this is not a section about budget nonsense. ;)
346 TopGit keeps its metadata in ``.topdeps`` and ``.topmsg`` files. In an effort
347 to facilitate cherry-picking and other Git activities on the patch changes
348 themselves while ignoring the TopGit metadata, TopGit attempts to keep all
349 changes to ``.topdeps`` and ``.topmsg`` files limited to commits that do NOT
350 contain changes to any other files.
352 This is a departure from previous TopGit versions that made no such effort.
354 Primarily this affects ``tg create`` and ``tg import`` (which makes use of
355 ``tg create``) as ``tg create`` will commit the initial versions of
356 ``.topdeps`` and ``.topmsg`` for a new TopGit-controlled branch in their own
357 commit instead of mixing them in with changes to other files.
359 The ``pre-commit`` hook will also attempt to separate out any ``.topdeps`` and
360 ``.topmsg`` changes from commits that include changes to other files.
362 It is possible to defeat these checks without much effort (``pre-commit`` hooks
363 can easily be bypassed, ``tg create`` has a ``--no-commit`` option, many Git
364 commands simply do not run the ``pre-commit`` hook, etc.).
366 If you really, really, really, really want to change the default back to the
367 old behavior of previous TopGit versions where no such sequestration took
368 place, then set the ``topgit.sequester`` config variable explicitly to the
369 value ``false``. But this is not recommended.
372 AMENDING AND REBASING AND UPDATE-REF'ING
373 ----------------------------------------
377 It is okay to manually update a top-bases/... ref when a) it has no depedencies
378 (i.e. it was created with the ``tg create`` ``--no-deps`` option) and b) the
379 old top-bases/... ref value can be fast-forwarded to the new top-bases/...
380 value OR the new value contains ALL of the changes in the old value through
381 some other mechanism (perhaps they were cherry-picked or otherwise applied to
382 the new top-bases/... ref). The same rules apply to non-TopGit-controlled
385 Ignoring this rule and proceeding anyway with a non-fast-forward update to a
386 top-bases/... ref will result in changes present in the new value being merged
387 into the branch (at ``tg update`` time) as expected (possibly with conflicts),
388 but any changes that were contained in the old version of the top-bases/... ref
389 which have been dropped (i.e. are NOT contained in the new version of the
390 top-bases/... ref) will continue to be present in the branch! To get rid of
391 the dropped commits, one or more "revert" commits will have to be manually
392 applied to the tip of the new top-bases/... value (which will then be merged
393 into the branch at next ``tg update`` time).
395 The only time it's safe to amend, rebase, filter or otherwise rewrite commits
396 contained in a TopGit controlled branch or non-TopGit branch is when those
397 commits are NOT reachable via any other ref!
399 Furthermore, while it is safe to rewrite merge commits (provided they meet the
400 same conditions) the merge commits themselves and the branches they are merging
401 in must be preserved during the rewrite and that can be rather tricky to get
402 right so it's not recommended.
404 For example, if, while working on a TopGit-controlled branch ``foo``, a bad
405 typo is noticed, it's okay to ammend/rebase to fix that provided neither
406 ``tg update`` nor ``tg create`` has already been used to cause some other ref
407 to be able to reach the commit with the typo.
409 If an amend or rerwite is done anyway even though the commit with the typo is
410 reachable from some other ref, the typo won't really be removed. What will
411 happen instead is that the new version without the typo will ultimately be
412 merged into the other ref(s) (at ``tg update`` time) likely causing a conflict
413 that will have to be manually resolved and the commit with the typo will
414 continue to be reachable from those other refs!
416 Instead just make a new commit to fix the typo. The end result will end up
417 being the same but without the merge conflicts.
419 See also the discussion in the `NO UNDO`_ section.
425 TopGit needs to check many things to determine whether a TopGit branch is
426 up-to-date or not. This can involve a LOT of git commands for a complex
427 dependency tree. In order to speed things up, TopGit keeps a cache of results
428 in a ``tg-cache`` subdirectory in the ``.git`` directory.
430 Results are tagged with the original hash values used to get that result so
431 that items which have not been changed return their results quickly and items
432 which have been changed compute their new result and cache it for future use.
434 The ``.git/tg-cache`` directory may be removed at any time and the cache will
435 simply be recreated in an on-demand fashion as needed, at some speed penalty,
436 until it's fully rebuilt.
438 To force the cache to be fully pre-loaded, run the ``tg summary`` command
439 without any arguments. Otherwise, normal day-to-day TopGit operations should
440 keep it more-or-less up-to-date.
442 While each TopGit command is running, it uses a temporary subdirectory also
443 located in the ``.git`` directory. These directories are named
444 ``tg-tmp.XXXXXX`` where the ``XXXXXX`` part will be random letters and digits.
446 These temporary directories should always be removed automatically after each
447 TopGit command finishes running. As long as you are not in a subshell as a
448 result of a TopGit command stopping and waiting for a manual merge resolution,
449 it's safe to remove any of these directories that may have somehow accidentally
450 been left behind as a result of some failure that occurred while running a
451 TopGit command (provided, of course, it's not actually being used by a TopGit
452 command currently running in another terminal window or by another user on the
458 ``tg [-C <dir>] [-r <remote> | -u] [-c <name>=<val>] <subcommand> [<subcommand option/argument>...]``
460 -C <dir> Change directory to <dir> before doing anything
461 -r <remote> Pretend ``topgit.remote`` is set to <remote>
462 -u Pretend ``topgit.remote`` is not set
463 -c <name=val> Pass config option to git, may be repeated
465 The ``tg`` tool has several subcommands:
467 :`tg annihilate`_: Mark a TopGit-controlled branch as defunct
468 :`tg base`_: Show base commit for one or more TopGit branches
469 :`tg checkout`_: Shortcut for git checkout with name matching
470 :`tg create`_: Create a new TopGit-controlled branch
471 :`tg delete`_: Delete a TopGit-controlled branch cleanly
472 :`tg depend`_: Add a new dependency to a TopGit-controlled branch
473 :`tg export`_: Export TopGit branch patches to files or a branch
474 :`tg files`_: Show files changed by a TopGit branch
475 :`tg help`_: Show TopGit help optionally using a browser
476 :`tg import`_: Import commit(s) to separate TopGit branches
477 :`tg info`_: Show status information about a TopGit branch
478 :`tg log`_: Run git log limiting revisions to a TopGit branch
479 :`tg mail`_: Shortcut for git send-email with ``tg patch`` output
480 :`tg migrate-bases`_: Transition top-bases to new location
481 :`tg next`_: Show branches directly depending on a TopGit branch
482 :`tg patch`_: Generate a patch file for a TopGit branch
483 :`tg prev`_: Show non-annihilated TopGit dependencies for a branch
484 :`tg push`_: Run git push on TopGit branch(es) and depedencies
485 :`tg rebase`_: Auto continue git rebase if rerere resolves conflicts
486 :`tg remote`_: Set up remote for fetching/pushing TopGit branches
487 :`tg revert`_: Revert ref(s) to a state stored in a ``tg tag``
488 :`tg status`_: Show current TopGit status (e.g. in-progress update)
489 :`tg summary`_: Show various information about TopGit branches
490 :`tg tag`_: Create tag that records current TopGit branch state
491 :`tg update`_: Update TopGit branch(es) with respect to dependencies
495 Our sophisticated integrated help facility. Mostly duplicates
500 # to get help for a particular command:
502 # to get help for a particular command in a browser window:
503 $ tg help -w <command>
504 # to get help on TopGit itself
506 # to get help on TopGit itself in a browser
511 Our sophisticated status facility. Similar to Git's status command
512 but shows any in-progress update that's awaiting a merge resolution
513 or any other on-going TopGit activity (such as a branch creation).
515 With a single ``--verbose`` (or ``-v``) option include a short status
516 display for any dirty (but not untracked) files. This also causes all
517 non file status lines to be prefixed with "## ".
519 With two (or more) ``--verbose`` (or ``-v``) options, additionally
520 show full symbolic ref names and unabbreviated hash values.
522 With the ``--exit-code`` option the exit code will be non-zero if any
523 TopGit or Git operation is currently in progress or the working
528 Create a new TopGit-controlled topic branch of the given name
529 (required argument) and switch to it. If no dependencies are
530 specified (by extra arguments passed after the first one), the
531 current branch is assumed to be the only dependency.
533 By default ``tg create`` opens an editor on the new ``.topmsg`` file
534 and then commits the new ``.topmsg`` and ``.topdeps`` files
535 automatically with a suitable default commit message.
537 The commit message can be changed with the ``-m`` (or ``--message``) or
538 ``-F`` (or ``--file``) option. The automatic commit can be suppressed
539 by using the ``--no-ccmmit`` option. Running the editor on the new
540 ``.topmsg`` file can be suppressed by using ``-n`` (or ``--no-edit``)
541 (which also suppresses the automatic commit) or by providing an
542 explicit value for the new ``.topmsg`` file using the ``--topmsg`` or
543 ``--topmsg-file`` option. In any case the ``.topmsg`` content will be
544 automatically reformated to have a ``Subject:`` header line if needed.
546 If more than one dependency is listed, the automatic commit will not
547 take place until AFTER all the listed dependencies have been merged
548 into a base commit which will require some manual merge resolutions if
549 conflicts occur during the merge operations.
551 Previous versions of TopGit behaved as though the ``--no-edit`` option
552 was always given on the command line.
554 The default behavior has been changed to promote a separation between
555 commits that modify ``.topmsg`` and/or ``.topdeps`` and commits that
556 modify other files. This facilitates cleaner cherry picking and other
557 patch maintenance activities.
559 You should edit the patch description (contained in the ``.topmsg``
560 file) as appropriate. It will already contain some prefilled bits.
561 You can set the ``topgit.to``, ``topgit.cc`` and ``topgit.bcc``
562 git configuration variables (see ``man git-config``) in order to
563 have ``tg create`` add these headers with the given default values
564 to ``.topmsg`` before invoking the editor.
566 The main task of ``tg create`` is to set up the topic branch base
567 from the dependencies. This may fail due to merge conflicts if more
568 than one dependency is given. In that case, after you commit the
569 conflict resolution, you should call ``tg update --continue`` to
570 finish merging the dependencies into the new topic branch base.
572 With the ``--no-deps`` option at most one dependency may be listed
573 which may be any valid committish (instead of just refs/heads/...) and
574 the newly created TopGit-controlled branch will have an empty
575 ``.topdeps`` file. This may be desirable in order to create a TopGit-
576 controlled branch that has no changes of its own and serves merely to
577 mark the common dependency that all other TopGit-controlled branches
578 in some set of TopGit-controlled branches depend on. A plain,
579 non-TopGit-controlled branch can be used for the same purpose, but the
580 advantage of a TopGit-controlled branch with no dependencies is that it
581 will be pushed with ``tg push``, it will show up in the ``tg summary``
582 and ``tg info`` output with the subject from its ``.topmsg`` file
583 thereby documenting what it's for and finally it can be set up with
584 ``tg create -r`` and/or ``tg remote --populate`` to facilitate sharing.
586 For example, ``tg create --no-deps release v2.1`` will create a TopGit-
587 controlled ``release`` branch based off the ``v2.1`` tag that can then
588 be used as a base for creation of other TopGit-controlled branches.
589 Then when the time comes to move the base for an entire set of changes
590 up to ``v2.2`` the command ``git update-ref top-bases/release v2.2^0``
591 can be used followed by ``tg update --all``. Note that it's only safe
592 to update ``top-bases/release`` directly in this manner because a) it
593 has no depedencies since it was created with the ``--no-deps`` option
594 and b) the old ``top-bases/release`` value can be fast-forwarded to the
595 new ``top-bases/release`` value.
597 Using ``--no-deps`` it's also possible to use ``tg create`` on an
598 unborn branch (omit the dependency name or specify ``HEAD``). The
599 unborn branch itself can be made into the new TopGit branch (rather
600 than being born empty and then having the new TopGit branch based off
601 that) by specifying ``HEAD`` as the new branch's name (which is
602 probably what you normally want to do in this case anyway so you can
603 just run ``tg create --no-deps HEAD`` to accomplish that).
605 In an alternative use case, if ``-r <branch>`` is given instead of a
606 dependency list, the topic branch is created based on the given
607 remote branch. With just ``-r`` the remote branch name is assumed
608 to be the same as the local topic branch being created. Since no
609 new commits are created in this mode (only two refs will be updated)
610 the editor will never be run for this use case. Note that no other
611 options may be combined with ``-r``.
613 The ``--quiet`` (or ``-q``) option suppresses most informational
618 Remove a TopGit-controlled topic branch of the given name
619 (required argument). Normally, this command will remove only an
620 empty branch (base == head) without dependendents; use ``-f`` to
621 remove a non-empty branch or a branch that is depended upon by
624 The ``-f`` option is also useful to force removal of a branch's
625 base, if you used ``git branch -D B`` to remove branch B, and then
626 certain TopGit commands complain, because the base of branch B
629 Normally ``tg delete`` will refuse to delete the current branch.
630 However, giving ``-f`` twice (or more) will force it to do so but it
631 will first detach your HEAD.
633 IMPORTANT: Currently, this command will *NOT* remove the branch
634 from the dependency list in other branches. You need to take
635 care of this *manually*. This is even more complicated in
636 combination with ``-f`` -- in that case, you need to manually
637 unmerge the removed branch's changes from the branches depending
640 See also ``tg annihilate``.
642 | TODO: ``-a`` to delete all empty branches, depfix, revert
646 Make a commit on the current TopGit-controlled topic branch
647 that makes it equal to its base, including the presence or
648 absence of .topmsg and .topdeps. Annihilated branches are not
649 displayed by ``tg summary``, so they effectively get out of your
650 way. However, the branch still exists, and ``tg push`` will
651 push it (except if given the ``-a`` option). This way, you can
652 communicate that the branch is no longer wanted.
654 When annihilating a branch that has dependents (i.e. branches
655 that depend on it), those dependents have the dependencies of
656 the branch being annihilated added to them if they do not already
657 have them as dependencies. Essentially the DAG is repaired to
658 skip over the annihilated branch.
660 Normally, this command will remove only an empty branch
661 (base == head, except for changes to the .top* files); use
662 ``-f`` to annihilate a non-empty branch.
664 After completing the annihilation itself, normally ``tg update``
665 is run on any modified dependents. Use the ``--no-update`` option
666 to suppress running ``tg update``.
670 Change the dependencies of a TopGit-controlled topic branch.
671 This should have several subcommands, but only ``add`` is
674 The ``add`` subcommand takes an argument naming a topic branch to
675 be added, adds it to ``.topdeps``, performs a commit and then
676 updates your topic branch accordingly. If you want to do other
677 things related to the dependency addition, like adjusting
678 ``.topmsg``, use the option ``--no-commit``. Adding the
679 ``--no-update`` (or ``--no-commit``) option will suppress the
680 ``tg update`` normally performed after committing the change.
682 It is safe to run ``tg depend add`` in a dirty worktree, but the
683 normally performed ``tg update`` will be suppressed in that case
684 (even if neither ``--no-update`` nor ``--no-commit`` is given).
686 You have enabled ``git rerere`` haven't you?
688 | TODO: Subcommand for removing dependencies, obviously
692 List files changed by the current or specified topic branch.
695 -i list files based on index instead of branch
696 -w list files based on working tree instead of branch
700 Show summary information about the current or specified topic
703 Numbers in parenthesis after a branch name such as "(11/3 commits)"
704 indicate how many commits on the branch (11) and how many of those
705 are non-merge commits (3).
707 Alternatively, if ``--heads`` is used then which of the independent
708 TopGit branch heads (as output by ``tg summary --tgish-only --heads)``
709 contains the specified commit (which may be any committish -- defaults
710 to ``HEAD`` if not given). Zero or more results will be output.
712 If ``--leaves`` is used then the unique list of leaves of the current
713 or specified topic branch is shown as one fully-qualified ref per line.
714 Duplicates are suppressed and a tag name will be used when appropriate.
715 A "leaf" is any dependency that is either not a TopGit branch or is
716 the base of a non-annihilated TopGit branch with no non-annihilated
719 A linearized patch series can only be automatically created for a
720 TopGit topic branch (including its recursive dependencies) when exactly
721 one line is output by ``tg info --leaves <topic-branch>``.
725 Generate a patch from the current or specified topic branch.
726 This means that the diff between the topic branch base and head
727 (latest commit) is shown, appended to the description found in
728 the ``.topmsg`` file.
730 The patch is simply dumped to stdout. In the future, ``tg patch``
731 will be able to automatically send the patches by mail or save
732 them to files. (TODO)
735 -i base patch generation on index instead of branch
736 -w base patch generation on working tree instead of branch
737 --binary pass --binary to ``git diff-tree`` to enable generation
739 --diff-opt options after the branch name (and an optional ``--``)
740 are passed directly to ``git diff-tree``
742 In order to pass a sole explicit ``-w`` through to ``git diff-tree`` it
743 must be separated from the ``tg`` options by an explicit ``--``.
744 Or it can be spelled as ``--ignore-all-space`` to distinguuish it from
745 ``tg``'s ``-w`` option.
747 If additional non-``tg`` options are passed through to
748 ``git diff-tree`` (other than ``--binary`` which is fully supported)
749 the resulting ``tg patch`` output may not be appliable.
753 Send a patch from the current or specified topic branch as
756 Takes the patch given on the command line and emails it out.
757 Destination addresses such as To, Cc and Bcc are taken from the
760 Since it actually boils down to ``git send-email``, please refer
761 to the documentation for that for details on how to setup email
762 for git. You can pass arbitrary options to this command through
763 the ``-s`` parameter, but you must double-quote everything. The
764 ``-r`` parameter with a msgid can be used to generate in-reply-to
765 and reference headers to an earlier mail.
767 WARNING: be careful when using this command. It easily sends
768 out several mails. You might want to run::
770 git config sendemail.confirm always
772 to let ``git send-email`` ask for confirmation before sending any
776 -i base patch generation on index instead of branch
777 -w base patch generation on working tree instead of branch
779 | TODO: ``tg mail patchfile`` to mail an already exported patch
780 | TODO: mailing patch series
781 | TODO: specifying additional options and addresses on command line
785 Register the given remote as TopGit-controlled. This will create
786 the namespace for the remote branch bases and teach ``git fetch``
787 to operate on them. However, from TopGit 0.8 onwards you need to
788 use ``tg push``, or ``git push --mirror``, for pushing
789 TopGit-controlled branches.
791 ``tg remote`` takes an optional remote name argument, and an
792 optional ``--populate`` switch. Use ``--populate`` for your
793 origin-style remotes: it will seed the local topic branch system
794 based on the remote topic branches. ``--populate`` will also make
795 ``tg remote`` automatically fetch the remote, and ``tg update`` look
796 at branches of this remote for updates by default.
798 Using ``--populate`` with a remote name causes the ``topgit.remote``
799 git configuration variable to be set to the given remote name.
803 Show overview of all TopGit-tracked topic branches and their
804 up-to-date status. With a branch name limit output to that branch.
805 Using ``--deps-only`` or ``--rdeps`` changes the default from all
806 branches to just the current ``HEAD`` branch but using ``--all`` as
807 the branch name will show results for all branches instead of ``HEAD``.
810 marks the current topic branch
813 indicates that it introduces no changes of its own
816 indicates respectively whether it is local-only
820 indicates respectively if it is ahead or out-of-date
821 with respect to its remote mate
824 indicates that it is out-of-date with respect to its
828 indicates that it has missing dependencies [even if
829 they are recursive ones]
832 indicates that it is out-of-date with respect to
835 This can take a longish time to accurately determine all the
836 relevant information about each branch; you can pass ``-t`` (or ``-l``
837 or ``--list``) to get just a terse list of topic branch names quickly.
839 Passing ``--heads`` shows independent topic branch names and when
840 combined with ``--rdeps`` behaves as though ``--rdeps`` were run with
841 the output of ``--heads``.
843 Using ``--heads-only`` behaves as though the output of ``--heads`` was
844 passed as the list of branches along with ``--without-deps``.
846 Alternatively, you can pass ``--graphviz`` to get a dot-suitable output
847 for drawing a dependency graph between the topic branches.
849 You can also use the ``--sort`` option to sort the branches using
850 a topological sort. This is especially useful if each
851 TopGit-tracked topic branch depends on a single parent branch,
852 since it will then print the branches in the dependency order.
853 In more complex scenarios, a text graph view would be much more
854 useful, but that has not yet been implemented.
856 The ``--deps`` option outputs dependency information between
857 branches in a machine-readable format. Feed this to ``tsort`` to
858 get the output from --sort.
860 The ``--deps-only`` option outputs a sorted list of the unique branch
861 names given on the command line plus all of their recursive
862 dependencies (subject to ``--exclude`` of course). When
863 ``--deps-only`` is given the default is to just display information for
864 ``HEAD``, but that can be changed by using ``--all`` as the branch
865 name. Each branch name will appear only once in the output no matter
866 how many times it's visited while tracing the dependency graph or how
867 many branch names are given on the command line to process.
869 The ``--rdeps`` option outputs dependency information in an indented
870 text format that clearly shows all the dependencies and their
871 relationships to one another. When ``--rdeps`` is given the default is
872 to just display information for ``HEAD``, but that can be changed by
873 using ``--all`` as the branch name or by adding the ``--heads`` option.
874 Note that ``tg summary --rdeps --heads`` can be particularly helpful in
875 seeing all the TopGit-controlled branches in the repository and their
876 relationships to one another.
878 Adding ``--with-deps`` replaces the given list of branches (which will
879 default to ``HEAD`` if none are given) with the result of running
880 ``tg summary --deps-only --tgish`` on the list of branches. This can
881 be helpful in limiting ``tg summary`` output to only the list of given
882 branches and their dependencies when many TopGit-controlled branches
883 are present in the repository. When it would be allowed,
884 ``--with-deps`` is now the default. Use ``--without-deps`` to switch
885 back to the old behavior.
887 With ``--exclude branch``, branch can be excluded from the output
888 meaning it will be skipped and its name will be omitted from any
889 dependency output. The ``--exclude`` option may be repeated to omit
890 more than one branch from the output. Limiting the output to a single
891 branch that has been excluded will result in no output at all.
893 The ``--tgish-only`` option behaves as though any non-TopGit-controlled
894 dependencies encountered during processing had been listed after an
895 ``--exclude`` option.
897 Note that the branch name can be specified as ``HEAD`` or ``@`` as a
898 shortcut for the TopGit-controlled branch that ``HEAD`` is a
899 symbolic ref to. The ``tg summary @`` command can be quite useful.
902 -i Use TopGit metadata from the index instead of the branch
903 -w Use TopGit metadata from the working tree instead of the branch
908 Switch to a topic branch. You can use ``git checkout <branch>``
909 to get the same effect, but this command helps you navigate
910 the dependency graph, or allows you to match the topic branch
911 name using a regular expression, so it can be more convenient.
913 There following subcommands are available:
916 Check out a branch that directly
917 depends on your current branch.
920 Check out a branch that this branch
923 ``tg checkout [goto] [--] <pattern>``
924 Check out a topic branch that
925 matches ``<pattern>``. ``<pattern>``
926 is used as a sed pattern to filter
927 all the topic branches. Both ``goto`` and
928 ``--`` may be omitted provided ``<pattern>``
929 is not ``push``, ``pop``, ``-a``, ``--all``,
930 ``goto``, ``..``, ``--``, ``next``, ``child``,
931 ``prev``, ``parent``, ``-h`` or ``--help``.
934 An alias for ``push``.
936 ``tg checkout child``
937 An alias for ``push``.
940 An alias for ``push``.
943 An alias for ``pop``.
945 ``tg checkout parent``
946 An alias for ``pop``.
949 An alias for ``pop``.
951 If any of the above commands can find more than one possible
952 branch to switch to, you will be presented with the matches
953 and asked to select one of them.
955 The ``<pattern>`` of ``tg checkout goto`` is optional. If you don't
956 supply it, all the available topic branches are listed and you
957 can select one of them.
959 Normally, the ``push`` and ``pop`` commands moves one step in
960 the dependency graph of the topic branches. The ``-a`` option
961 causes them (and their aliases) to move as far as possible.
962 That is, ``tg checkout push -a`` moves to a topic branch that
963 depends (directly or indirectly) on the current branch and
964 that no other branch depends on. ``tg checkout pop -a``
965 moves to a regular branch that the current topic branch
966 depends on (directly or indirectly). If there is more than
967 one possibility, you will be prompted for your selection.
971 Export a tidied-up history of the current topic branch and its
972 dependencies, suitable for feeding upstream. Each topic branch
973 corresponds to a single commit or patch in the cleaned up
974 history (corresponding basically exactly to ``tg patch`` output
975 for the topic branch).
977 The command has three possible outputs now -- either a Git branch
978 with the collapsed history, a Git branch with a linearized
979 history, or a quilt series in new directory.
981 In the case where you are producing collapsed history in a new
982 branch, you can use this collapsed structure either for
983 providing a pull source for upstream, or for further
984 linearization e.g. for creation of a quilt series using git log::
986 git log --pretty=email -p --topo-order origin..exported
988 To better understand the function of ``tg export``, consider this
989 dependency structure::
991 origin/master - t/foo/blue - t/foo/red - master
992 `- t/bar/good <,----------'
993 `- t/baz ------------'
995 (where each of the branches may have a hefty history). Then::
997 master$ tg export for-linus
999 will create this commit structure on the branch ``for-linus``::
1001 origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
1002 `- t/bar/good <,-------------------'/
1003 `- t/baz ---------------------'
1005 In this mode, ``tg export`` works on the current topic branch, and
1006 can be called either without an option (in that case,
1007 ``--collapse`` is assumed), or with the ``--collapse`` option, and
1008 with one mandatory argument: the name of the branch where the
1009 exported result will be stored.
1011 When using the linearize mode::
1013 master$ tg export --linearize for-linus
1015 you get a linear history respecting the dependencies of your
1016 patches in a new branch ``for-linus``. The result should be more
1017 or less the same as using quilt mode and then reimporting it
1018 into a Git branch. (More or less because the topological order
1019 can usually be extended in more than one way into a total order,
1020 and the two methods may choose different ones.) The result
1021 might be more appropriate for merging upstream, as it contains
1024 Note that you might get conflicts during linearization because
1025 the patches are reordered to get a linear history. If linearization
1026 would produce conflicts then using ``--quilt`` will also likely result
1027 in conflicts when the exported quilt series is applied. Since the
1028 ``--quilt`` mode simply runs a series of ``tg patch`` commands to
1029 generate the patches in the exported quilt series and those patches
1030 will end up being applied linearly, the same conflicts that would be
1031 produced by the ``--linearize`` option will then occur at that time.
1033 To avoid conflicts produced by ``--linearize`` (or by applying the
1034 ``--quilt`` output), use the default ``--collapse`` mode and then use
1035 ``tg rebase`` (or ``git rebase -m`` directly) on the collapsed branch
1036 (with a suitable <upstream>) followed by ``git format-patch`` on the
1037 rebased result to produce a conflict-free patch set. A suitable
1038 upstream may be determined with the ``tg info --leaves`` command (if
1039 it outputs more than one line, linearization will be problematic).
1041 You have enabled ``git rerere`` haven't you?
1043 When using the quilt mode::
1045 master$ tg export --quilt for-linus
1047 would create the following directory ``for-linus``::
1049 for-linus/t/foo/blue.diff
1050 for-linus/t/foo/red.diff
1051 for-linus/t/bar/good.diff
1052 for-linus/t/baz.diff
1059 With ``--quilt``, you can also pass the ``-b`` parameter followed
1060 by a comma-separated explicit list of branches to export, or
1061 the ``--all`` parameter (which can be shortened to ``-a``) to
1062 export them all. The ``--binary`` option enables producing Git
1063 binary patches. These options are currently only supported
1066 In ``--quilt`` mode the patches are named like the originating
1067 topgit branch. So usually they end up in subdirectories of the
1068 output directory. With the ``--flatten`` option the names are
1069 mangled so that they end up directly in the output dir (slashes
1070 are replaced with underscores). With the ``--strip[=N]`` option
1071 the first ``N`` subdirectories (all if no ``N`` is given) get
1072 stripped off. Names are always ``--strip``'d before being
1073 ``--flatten``'d. With the option ``--numbered`` (which implies
1074 ``--flatten``) the patch names get a number as prefix to allow
1075 getting the order without consulting the series file, which
1076 eases sending out the patches.
1078 | TODO: Make stripping of non-essential headers configurable
1079 | TODO: Make stripping of [PATCH] and other prefixes configurable
1080 | TODO: ``--mbox`` option to export instead as an mbox file
1081 | TODO: support ``--all`` option in other modes of operation
1082 | TODO: For quilt exporting, export the linearized history created in
1083 a temporary branch--this would allow producing conflict-less
1088 Import commits within the given revision range into TopGit,
1089 creating one topic branch per commit. The dependencies are set
1090 up to form a linear sequence starting on your current branch --
1091 or a branch specified by the ``-d`` parameter, if present.
1093 The branch names are auto-guessed from the commit messages and
1094 prefixed by ``t/`` by default; use ``-p <prefix>`` to specify an
1095 alternative prefix (even an empty one).
1097 Alternatively, you can use the ``-s NAME`` parameter to specify
1098 the name of the target branch; the command will then take one
1099 more argument describing a *single* commit to import.
1103 Update the current, specified or all topic branches with respect
1104 to changes in the branches they depend on and remote branches.
1105 This is performed in two phases -- first, changes within the
1106 dependencies are merged to the base, then the base is merged
1107 into the topic branch. The output will guide you on what to do
1108 next in case of conflicts.
1110 You have enabled ``git rerere`` haven't you?
1112 When ``-a`` (or ``--all``) is specifed, updates all topic branches
1113 matched by ``<pattern>``'s (see ``git-for-each-ref(1)`` for details),
1114 or all if no ``<pattern>`` is given. Any topic branches with missing
1115 dependencies will be skipped entirely unless ``--skip-missing`` is
1118 When ``--skip-missing`` is specifed, an attempt is made to update topic
1119 branches with missing dependencies by skipping only the dependencies
1120 that are missing. Caveat utilitor.
1122 When ``--stash`` is specified (or the ``topgit.autostash`` config
1123 value is set to ``true``), a ref stash will be automatically created
1124 just before beginning updates if any are needed. The ``--no-stash``
1125 option may be used to disable a ``topgit.autostash=true`` setting.
1126 See the ``tg tag`` ``--stash`` option for details.
1128 After the update, if a single topic branch was specified, it is
1129 left as the current one; if ``-a`` was specified, it returns to
1130 the branch which was current at the beginning.
1132 If your dependencies are not up-to-date, ``tg update`` will first
1133 recurse into them and update them.
1135 If a remote branch update brings in dependencies on branches
1136 that are not yet instantiated locally, you can either bring in
1137 all the new branches from the remote using ``tg remote
1138 --populate``, or only pick out the missing ones using ``tg create
1139 -r`` (``tg summary`` will point out branches with incomplete
1140 dependencies by showing an ``!`` next to them).
1142 | TODO: ``tg update -a -c`` to autoremove (clean) up-to-date branches
1146 If ``-a`` or ``--all`` was specified, pushes all non-annihilated
1147 TopGit-controlled topic branches, to a remote repository.
1148 Otherwise, pushes the specified topic branches -- or the
1149 current branch, if you don't specify which. By default, the
1150 remote gets all the dependencies (both TopGit-controlled and
1151 non-TopGit-controlled) and bases pushed to it too. If
1152 ``--tgish-only`` was specified, only TopGit-controlled
1153 dependencies will be pushed, and if ``--no-deps`` was specified,
1154 no dependencies at all will be pushed.
1156 The ``--dry-run`` and ``--force`` options are passed directly to
1157 ``git push`` if given.
1159 The remote may be specified with the ``-r`` option. If no remote
1160 was specified, the configured default TopGit remote will be
1165 Prints the base commit of each of the named topic branches, or
1166 the current branch if no branches are named. Prints an error
1167 message and exits with exit code 1 if the named branch is not
1172 Prints the git log of the named topgit branch -- or the current
1173 branch, if you don't specify a name.
1175 This is really just a convenient shortcut for:
1177 ``git log --first-parent --no-merges $(tg base <name>)..<name>``
1179 where ``<name>`` is the name of the TopGit topic branch (or omitted
1180 for the current branch).
1182 NOTE: if you have merged changes from a different repository, this
1183 command might not list all interesting commits.
1187 Creates a TopGit annotated/signed tag or lists the reflog of one.
1189 A TopGit annotated tag records the current state of one or more TopGit
1190 branches and their dependencies and may be used to revert to the tagged
1191 state at any point in the future.
1193 When reflogs are enabled (the default in a non-bare repository) and
1194 combined with the ``--force`` option a single tag name may be used as a
1195 sort of TopGit branch state stash. The special branch name ``--all``
1196 may be used to tag the state of all current TopGit branches to
1197 facilitate this function and has the side-effect of suppressing the
1198 out-of-date check allowing out-of-date branches to be included.
1200 As a special feature, ``--stash`` may be used as the tag name in which
1201 case ``--all`` is implied if no branch name is listed (instead of the
1202 normal default of ``HEAD``), ``--force`` and ``--no-edit`` (use
1203 ``--edit`` to change that) are automatically activated and the tag will
1204 be saved to ``refs/tgstash`` instead of ``refs/tags/<tagname>``.
1205 The ``--stash`` tag name may also be used with the ``-g``/``--reflog``
1208 The mostly undocumented option ``--allow-outdated`` will bypass the
1209 out-of-date check and is implied when ``--stash`` or ``--all`` is used.
1211 A TopGit annotated/signed tag is simply a Git annotated/signed tag with
1212 a "TOPGIT REFS" section appended to the end of the tag message (and
1213 preceding the signature for signed tags). PEM-style begin and end
1214 lines surround one line per ref where the format of each line is
1215 full-hash SP ref-name. A line will be included for each branch given
1216 on the command line and each ref they depend on either directly or
1219 If more than one TopGit branch is given on the command line, a new
1220 commit will be created that has an empty tree and all of the given
1221 TopGit branches as parents and that commit will be tagged. If a single
1222 TopGit branch is given, then it will be tagged. If the ``--tree``
1223 option is used then it will be used instead of an empty tree (a new
1224 commit will be created if necessary to guarantee the specified tree is
1225 what's in the commit the newly created tag refers to). The argument to
1226 the ``--tree`` option may be any valid treeish.
1228 All the options for creating a tag serve the same purpose as their Git
1229 equivalents except for two. The ``--refs`` option suppresses tag
1230 creation entirely and emits the "TOPGIT REFS" section that would have
1231 been included with the tag. If the ``--no-edit`` option is given and
1232 no message is supplied (via the ``-m`` or ``-F`` option) then the
1233 default message created by TopGit will be used without running the
1236 With ``-g`` or ``--reflog`` show the reflog for a tag. With the
1237 ``--reflog-message`` option the message from the reflog is shown.
1238 With the ``--commit-message`` option the first line of the tag's
1239 message (if the object is a tag) or the commit message (if the object
1240 is a commit) falling back to the reflog message for tree and blob
1241 objects is shown. The default is ``--reflog-message`` unless the
1242 ``--stash`` (``refs/tgstash``) is being shown in which case the default
1243 is then ``--commit-message``. Just add either option explicitly to
1244 override the default.
1246 When showing reflogs, non-tag entries are annotated with their type
1247 unless ``--no-type`` is given.
1249 TopGit tags are created with a reflog if core.logallrefupdates is
1250 enabled (the default for non-bare repositories). Unfortunately Git
1251 is incapable of showing an annotated/signed tag's reflog
1252 (using git log -g) as it will first resolve the tag before checking to
1253 see if it has a reflog. Git can, however, show reflogs for lightweight
1254 tags (using git log -g) just fine but that's not helpful here. Use
1255 ``tg tag`` with the ``-g`` or ``--reflog`` option to see the reflog for
1256 an actual tag object. This also works on non-TopGit annotated/signed
1257 tags as well provided they have a reflog.
1259 The number of entries shown may be limited with the ``-n`` option. If
1260 the tagname is omitted then ``--stash`` is assumed.
1262 The ``--delete`` option is a convenience option that runs the
1263 ``git update-ref -d`` command on the specified tag removing it and its
1264 reflog (if it has one).
1266 The ``--clear`` option clears all but the most recent (the ``@{0}``)
1267 reflog entries from the reflog for the specified tag. It's equivalent
1268 to dropping all the higher numbered reflog entries.
1270 The ``--drop`` option drops the specified reflog entry and requires the
1271 given tagname to have an ``@{n}`` suffix where ``n`` is the reflog
1272 entry number to be dropped. This is really just a convenience option
1273 that runs the appropriate ``git reflog delete`` command.
1275 Note that when combined with ``tg revert``, a tag created by ``tg tag``
1276 can be used to transfer TopGit branches. Simply create the tag, push
1277 it somewhere and then have the recipient run ``tg revert`` to recreate
1278 the TopGit branches. This may be helpful in situations where it's not
1279 feasible to push all the refs corresponding to the TopGit-controlled
1280 branches and their top-bases.
1284 Provides a ``git rebase`` rerere auto continue function. It may be
1285 used as a drop-in replacement front-end for ``git rebase -m`` that
1286 automatically continues the rebase when ``git rerere`` information is
1287 sufficient to resolve all conflicts.
1289 You have enabled ``git rerere`` haven't you?
1291 If the ``-m`` or ``--merge`` option is not present then ``tg rebase``
1292 will complain and not do anything.
1294 When ``git rerere`` is enabled, previously resolved conflicts are
1295 remembered and can be automatically staged (see ``rerere.autoUpdate``).
1297 However, even with auto staging, ``git rebase`` still stops and
1298 requires an explicit ``git rebase --continue`` to keep going.
1300 In the case where ``git rebase -m`` is being used to flatten history
1301 (such as after a ``tg export --collapse`` prior to a
1302 ``git format-patch``), there's a good chance all conflicts have already
1303 been resolved during normal merge maintenance operations so there's no
1304 reason ``git rebase`` could not automatically continue, but there's no
1305 option to make it do so.
1307 The ``tg rebase`` command provides a ``git rebase --auto-continue``
1310 All the same rebase options can be used (they are simply passed through
1311 to Git unchanged). However, the ``rerere.autoUpdate`` option is
1312 automatically temporarily enabled while running ``git rebase`` and
1313 should ``git rebase`` stop asking one to resolve and continue, but all
1314 conflicts have already been resolved and staged using rerere
1315 information, then ``git rebase --continue`` will be automatically run.
1319 Provides the ability to revert one or more TopGit branches and their
1320 dependencies to a previous state contained within a tag created using
1321 the ``tg tag`` command. In addition to the actual revert mode
1322 operation a list mode operation is also provided to examine a tag's ref
1325 The default mode (``-l`` or ``--list``) shows the state of one or more
1326 of the refs/branches stored in the tag data. When no refs are given on
1327 the command line, all refs in the tag data are shown. With the special
1328 ref name ``--heads`` then the indepedent heads contained in the tag
1329 data are shown. The ``--deps`` option shows the specified refs and all
1330 of their dependencies in a single list with no duplicates. The
1331 ``--rdeps`` option shows a display similar to ``tg summary --rdeps``
1332 for each ref or all independent heads if no ref is given on the command
1333 line. The standard ``--no-short``, ``--short=n`` etc. options may be
1334 used to override the default ``--short`` output. With ``--hash`` (or
1335 ``--hash-only``) show only the hash in ``--list`` mode in which case
1336 the default is ``--no-short``. The ``--hash`` option can be used much
1337 like the ``git rev-parse --verify`` command to extract a specific hash
1338 value out of a TopGit tag.
1340 The revert mode has three submodes, dry-run mode (``-n`` or
1341 ``--dry-run``), force mode (``-f`` or ``--force``) and interactive mode
1342 (``-i`` or ``--interactive``). If ``--dry-run`` (or ``-n``) is given
1343 no ref updates will actually be performed but what would have been
1344 updated is shown instead. If ``--interactive`` (or ``-i``) is given
1345 then the editor is invoked on an instruction sheet allowing manual
1346 selection of the refs to be updated before proceeding. Since revert is
1347 potentially a destructive operation, at least one of the submodes must
1348 be specified explicitly. If no refs are listed on the command line
1349 then all refs in the tag data are reverted. Otherwise the listed refs
1350 and all of their dependencies (unless ``--no-deps`` is given) are
1351 reverted. Unless ``--no-stash`` is given a new stash will be created
1352 using ``tg tag --stash`` (except, of course, in dry-run mode) just
1353 before actually performing the updates to facilitate recovery from
1356 Both modes accept fully-qualified (i.e. starts with ``refs/``) ref
1357 names as well as unqualified names (which will be assumed to be located
1358 under ``refs/heads/``). In revert mode a tgish ref will always have
1359 both its ``refs/heads/`` and ``refs/top-bases/`` values included no
1360 matter how it's listed unless ``--no-deps`` is given and the ref is
1361 fully qualified (i.e. starts with ``refs/``) or one or the other of its
1362 values was removed from the instruction sheet in interactive mode. In
1363 list mode a tgish ref will always have both its ``refs/heads/`` and
1364 ``refs/top-bases/`` values included only when using the ``--deps`` or
1365 ``--rdeps`` options.
1367 The ``--tgish-only`` option excludes non-tgish refs (i.e. refs that do
1368 not have a ``refs/heads/<name>``, ``refs/top-bases/<name>`` pair).
1370 The ``--exclude`` option (which can be repeated) excludes specific
1371 refs. If the name given to ``--exclude`` is not fully-qualified (i.e.
1372 starts with ``refs/``) then it will exclude both members of a tgish ref
1375 The ``--quiet`` (or ``-q``) option may be used in revert mode to
1376 suppress non-dry-run ref change status messages.
1378 The special tag name ``--stash`` (as well as with ``@{n}`` suffixes)
1379 can be used to refer to ``refs/tgstash``.
1381 The ``tg revert`` command supports tags of tags that contains TopGit
1382 refs. So, for example, if you do this::
1385 git tag -f -a -m "tag the tag" newtag newtag
1387 Then ``newtag`` will be a tag of a tag containing a ``TOPGIT REFS``
1388 section. ``tg revert`` knows how to dereference the outermost
1389 tag to get to the next (and the next etc.) tag to find the
1390 ``TOPGIT REFS`` section so after the above sequence, the tag ``newtag``
1391 can still be used successfully with ``tg revert``.
1393 NOTE: If HEAD points to a ref that is updated by a revert operation
1394 then NO WARNING whatsoever will be issued, but the index and working
1395 tree will always be left completely untouched (and the reflog for
1396 the pointed-to ref can always be used to find the previous value).
1400 Outputs the direct dependencies for the current or named branch.
1403 -i show dependencies based on index instead of branch
1404 -w show dependencies based on working tree instead of branch
1408 Outputs all branches which directly depend on the current or
1412 -i show dependencies based on index instead of branch
1413 -w show dependencies based on working tree instead of branch
1417 Transition top-bases from old location to new location.
1419 Beginning with TopGit release 0.19.4, TopGit has the ability to store
1420 the top-bases refs in either the old ``ref/top-bases/...`` location or
1421 the new ``refs/heads/{top-bases}/...`` location. Starting with TopGit
1422 release 0.20.0, the default is the new location.
1424 By storing the top-bases under heads, Git is less likely to complain
1425 when manipulating them, hosting providers are more likely to provide
1426 access to them and Git prevents them from pointing at anything other
1427 than a commit object. All in all a win for everyone.
1429 TopGit attempts to automatically detect whether the new or old location
1430 is being used for the top-bases and just do the right thing. However,
1431 by explicitly setting the config value ``topgit.top-bases`` to either
1432 ``refs`` for the old location or ``heads`` for the new location the
1433 auto-detection can be bypassed. If no top-bases refs are present in
1434 the repository the default prior to TopGit release 0.20.0 is to use the
1435 old location but starting with TopGit release 0.20.0 the default is to
1436 use the new location.
1438 The ``tg migrate-bases`` command may be used to migrate top-bases refs
1439 from the old location to the new location (or, by using the
1440 undocumented ``--reverse`` option, vice versa).
1442 With few exceptions (``tg create -r`` and ``tg revert``), all top-bases
1443 refs (both local *and* remote refs) are expected to be stored in the
1444 same location (either new or old). A repository's current location for
1445 storing top-bases refs may be shown with the ``tg --top-bases`` command.
1453 TopGit stores all the topic branches in the regular ``refs/heads/``
1454 namespace (so we recommend distinguishing them with the ``t/`` prefix).
1455 Apart from that, TopGit also maintains a set of auxiliary refs in
1456 ``refs/top-*``. Currently, only ``refs/top-bases/`` is used, containing the
1457 current *base* of the given topic branch -- this is basically a merge of
1458 all the branches the topic branch depends on; it is updated during ``tg
1459 update`` and then merged to the topic branch, and it is the base of a
1460 patch generated from the topic branch by ``tg patch``.
1462 All the metadata is tracked within the source tree and history of the
1463 topic branch itself, in ``.top*`` files; these files are kept isolated
1464 within the topic branches during TopGit-controlled merges and are of
1465 course omitted during ``tg patch``. The state of these files in base
1466 commits is undefined; look at them only in the topic branches
1467 themselves. Currently, two files are defined:
1470 Contains the description of the topic branch in a
1471 mail-like format, plus the author information, whatever
1472 Cc headers you choose or the post-three-dashes message.
1473 When mailing out your patch, basically only a few extra
1474 mail headers are inserted and then the patch itself is
1475 appended. Thus, as your patches evolve, you can record
1476 nuances like whether the particular patch should have
1477 To-list / Cc-maintainer or vice-versa and similar
1478 nuances, if your project is into that. ``From`` is
1479 prefilled from your current ``GIT_AUTHOR_IDENT``; other
1480 headers can be prefilled from various optional
1481 ``topgit.*`` git config options.
1484 Contains the one-per-line list of branches this branch
1485 depends on, pre-seeded by ``tg create``. A (continuously
1486 updated) merge of these branches will be the *base* of
1489 IMPORTANT: DO NOT EDIT ``.topdeps`` MANUALLY!!! If you do so, you need to
1490 know exactly what you are doing, since this file must stay in sync with
1491 the Git history information, otherwise very bad things will happen.
1493 TopGit also automagically installs a bunch of custom commit-related
1494 hooks that will verify whether you are committing the ``.top*`` files in a
1495 sane state. It will add the hooks to separate files within the ``hooks/``
1496 subdirectory, and merely insert calls to them to the appropriate hooks
1497 and make them executable (but will make sure the original hook's code is
1498 not called if the hook was not executable beforehand).
1500 Another automagically installed piece is a ``.git/info/attributes``
1501 specifier for an ``ours`` merge strategy for the files ``.topmsg`` and
1502 ``.topdeps``, and the (intuitive) ``ours`` merge strategy definition in
1509 There are two remaining issues with accessing topic branches in remote
1512 (i) Referring to remote topic branches from your local repository
1513 (ii) Developing some of the remote topic branches locally
1515 There are two somewhat contradictory design considerations here:
1517 (a) Hacking on multiple independent TopGit remotes in a single
1519 (b) Having a self-contained topic system in local refs space
1521 To us, (a) does not appear to be very convincing, while (b) is quite
1522 desirable for ``git-log topic`` etc. working, and increased conceptual
1525 Thus, we choose to instantiate all the topic branches of given remote
1526 locally; this is performed by ``tg remote --populate``. ``tg update``
1527 will also check if a branch can be updated from its corresponding remote
1528 branch. The logic needs to be somewhat involved if we are to "do the
1529 right thing". First, we update the base, handling the remote branch as
1530 if it was the first dependency; thus, conflict resolutions made in the
1531 remote branch will be carried over to our local base automagically.
1532 Then, the base is merged into the remote branch and the result is merged
1533 to the local branch -- again, to carry over remote conflict resolutions.
1534 In the future, this order might be adjustable on a per-update basis, in
1535 case local changes happen to be diverging more than the remote ones.
1536 (See the details in `The Update Process`_ for more in depth coverage.)
1538 All commands by default refer to the remote that ``tg remote --populate``
1539 was called on the last time (stored in the ``topgit.remote`` git
1540 configuration variable). You can manually run any command with a
1541 different base remote by passing ``-r REMOTE`` *before* the subcommand
1548 A familiarity with the terms in the GLOSSARY_ is helpful for understanding the
1549 content of this sections. See also the IMPLEMENTATION_ section.
1554 When a branch is "updated" using the ``tg update`` command the following steps
1557 1) The branch and all of its dependencies (and theirs recursively)
1558 are checked to see which ones are *out-of-date*. See glossary_.
1560 2) Each of the branch's direct dependencies (i.e. they are listed in
1561 the branch's ``.topdeps`` file) which is out of date is updated
1562 before proceeding (yup, this is a recursive process).
1564 3) Each of the branch's direct dependencies (i.e. they are listed in
1565 the branch's ``.topdes`` file) that was updated in the previous
1566 step is now merged into the branch's corresponding base. If a
1567 remote is involved, and the branch's corresponding base does NOT
1568 contain the remote branch's corresponding base that remote base is
1569 also merged into the branch's base at this time as well (it will be
1570 the first item merged into the branch's base).
1572 4) If the branch has a corresponding remote branch and the branch
1573 does not already contain it, it's merged into the branch's base
1574 (which was possibly already updated in step (3) to contain the
1575 remote branch's base but not the remote branch itself) on a detached
1576 HEAD. Yup, this step can be a bit confusing and no, the updated
1577 base from step (3) has not yet been merged into the branch itself
1578 yet either. If there is no remote branch this step does not apply.
1579 Using a detached HEAD allows the remote branch to be merged into the
1580 contents of the base without actually perturbing the base's ref.
1582 5) If there is a remote branch present then use the result of step (4)
1583 otherwise use the branch's base and merge that into the branch
1586 That's it! Simple, right? ;)
1588 Unless the auto stash option has been disabled (see `no undo`_, `tg update`_
1589 and `tg tag`_), a copy of all the old refs values will be stashed away
1590 immediately after step (1) before starting step (2), but only if anything is
1591 actually found to be out-of-date.
1596 The ``tg update`` command regularly performs merges while executing an update
1597 operation. In order to speed things up, it attempts to do in-index merges
1598 where possible. It accomplishes this by using a separate, temporary index
1599 file and the ``git read-tree -m --aggressive`` command possibly assisted by
1600 the ``git merge-index`` and ``git merge-file`` commands. This combination may
1601 be repeated more than once to perform an octopus in-index merge. If this
1602 fails, the files are checked out and a normal ``git merge`` three-way merge is
1603 performed (possily multiple times). If the normal ``git merge`` fails then
1604 user intervention is required to resolve the merge conflict(s) and continue.
1606 Since the ``tg annihilate``, ``tg create`` and ``tg depend add`` commands may
1607 end up running the ``tg update`` machinery behind the scenes to complete their
1608 operation they may also result in any of these merge strategies being used.
1610 In addition to the normal Git merge strategies (if the in-index merging fails),
1611 there are four possible TopGit merge strategies that may be shown. Since they
1612 all involve use of the ``git read-tree -m --aggressive`` command they are all
1613 variations of a "trivial aggressive" merge. The "trivial" part because all of
1614 the merges done by ``git read-tree -m`` are described as "trivial" and the
1615 "aggressive" part because the ``--aggressive`` option is always used.
1617 1) "trivial aggressive"
1618 Only two heads were involved and all merging was completed by
1619 the ``git read-tree -m --aggressive`` command.
1621 2) "trivial aggressive automatic"
1622 Only two heads were involved but after the
1623 ``git read-tree -m --aggressive`` command completed there were
1624 still unresolved items and ``git merge-index`` had to be run
1625 (using the ``tg index-merge-one-file`` driver) which ultimately
1626 ran ``git merge-file`` at least once to perform a simple
1627 automatic three-way merge. Hence the "automatic" description
1628 and the "Auto-merging ..." output line(s).
1630 3) "trivial aggressive octopus"
1631 This is the same as a "trivial aggressive" merge except that
1632 more than two heads were involved and after merging the first
1633 two heads, the ``git read-tree -m --aggressive`` step was
1634 repeated again on the result for each additional head. All
1635 merging was completed via multiple
1636 ``git read-tree -m --aggressive`` commands only.
1637 This beast is relatively rare in the wild.
1639 4) "trivial aggressive automatic octopus"
1640 This is very similar to the "trivial aggressive octopus"
1641 except that at least one of the ``git read-tree -m --aggressive``
1642 commands left unresolved items that were handled the same way
1643 as the "trivial aggressive automatic" strategy. This species
1644 is commonly seen in the wild.
1651 Version-controlled file stored at the root level of each
1652 TopGit branch that contains the patch header for a TopGit
1653 branch. See also IMPLEMENTATION_;
1656 Version-controlled file stored at the root level of each
1657 TopGit branch that lists the branch's dependencies one per
1658 line omitting the leading ``refs/heads/`` part. See also
1662 Given two Git commit identifiers (e.g. hashes) C1 and C2,
1663 commit C1 "contains" commit C2 if either they are the same
1664 commit or C2 can be reached from C1 by following one or more
1665 parent links from C1 (perhaps via one or more intermediate
1666 commits along the way). In other words, if C1 contains C2
1667 then C2 is an ancestor of C1 or conversely C1 is a descendant
1668 of C2. Since a TopGit branch name is also the name of a Git
1669 branch (something located under the ``refs/heads`` Git
1670 namespace) and similarly for a TopGit base, they can both be
1671 resolved to a Git commit identifier and then participate in
1672 a branch containment test. An easy mnemonic for this is
1673 "children contain the genes of their parents."
1676 See branch containment.
1679 Excellent system for managing a history of changes to one
1680 or more possibly interrelated patches.
1683 A Git branch that has an associated TopGit base. Conceptually
1684 it represents a single patch that is the difference between
1685 the associated TopGit base and the TopGit branch. In other
1686 words ``git diff-tree <TopGit base> <TopGit branch>`` except
1687 that any ``.topdeps`` and/or ``.topmsg`` files are excluded
1688 from the result and the contents of the ``.topmsg`` file from
1689 the TopGit branch is prefixed to the result.
1692 A Git branch that records the base upon which a TopGit branch's
1693 single conceptual "patch" is built. The name of the Git branch
1694 is derived from the TopGit branch name by stripping off the
1695 leading ``refs/heads/`` and appending the correct prefix where
1696 all TopGit bases are stored (typically either
1697 ``refs/top-bases/`` or ``refs/heads/{top-bases}/`` -- the
1698 prefix for any given repository can be shown by using the
1699 ``tg --top-bases`` command and updated using the
1700 ``tg migrate-bases`` command).
1702 All of a TopGit branch's dependencies are merged into the
1703 corresponding TopGit base during a ``tg update`` of a branch.
1708 TopGit ``[PATCH]`` branch
1709 A TopGit branch whose subject starts with ``[PATCH]``. By
1710 convention these TopGit branches contain a single patch
1711 (equivalent to a single patch file) and have at least one
1712 dependency (i.e. their ``.topdeps`` files are never empty).
1714 TopGit ``[BASE]`` branch
1715 A TopGit branch whose subject starts with ``[BASE]``. By
1716 convention these TopGit branches do not actually contain
1717 any changes and their ``.topdeps`` files are empty. They
1718 are used to control a base dependency that another set of
1719 branches depends on.
1721 TopGit ``[STAGE]`` branch
1722 A TopGit branch whose subject starts with ``[STAGE]``. By
1723 convention these TopGit branches do not actually contain any
1724 changes of their own but do have one or (typically) more
1725 dependencies in their ``.topdeps`` file. These branches are
1726 used to bring together one or (typically) more independent
1727 TopGit ``[PATCH]`` branches into a single branch so that
1728 testing and/or evaluation can be performed on the result.
1731 When merging two (or more) heads that touch the same lines in
1732 the file but in different ways the result is a merge conflict
1733 that requires manual intervention. If a merge conflict occurs
1734 with more than two heads (an octopus merge) it's generally
1735 replaced by multiple three-way merges so that by the time a
1736 user sees a merge conflict needing manual resolution, there
1737 will be only two heads involved.
1740 A Git merge strategy (see the "MERGE STRATEGIES" section of
1741 ``git help merge``) or one of the TopGit `merge strategies`_
1742 used to merge two or more heads.
1744 TopGit merge strategy
1745 See the `Merge Strategies`_ section above for details but
1746 basically these are just in-index merges done using the
1747 ``git read-tree -m --aggressive`` command one or more times
1748 possibily assisted by the ``git merge-index`` and the
1749 ``git merge-file`` commands.
1752 A merge involving more than two heads. Note that if there are
1753 less than three independent heads the resulting merge that
1754 started out as an octopus will end up not actually being an
1758 A TopGit branch is considered to be "out-of-date" when ANY of
1759 the following are true:
1761 a) The TopGit branch does NOT contain its
1764 b) The TopGit branch does NOT contain its
1765 corresponding remote branch (there may not be
1766 a remote branch in which case this does not apply)
1768 c) The TopGit branch's base does NOT contain its
1769 corresponding remote branch's base (there may not be
1770 a remote branch in which case this does not apply)
1772 d) Any of the TopGit branches listed in the branch's
1773 ``.topdeps`` file are NOT contained by the branch.
1774 (See "branch containment" above.)
1776 e) Any of the TopGit branches listed in the branch's
1777 ``.topdeps`` file are out-of-date.
1779 Note that if a remote branch is present and is NOT out-of-date
1780 then it will contain its own base and (c) is mostly redundant.
1782 remote TopGit branch
1783 A Git branch with the same branch name as a TopGit branch
1784 but living under ``refs/remotes/<some remote>/`` instead
1785 of just ``refs/heads/``.
1788 The TopGit base branch corresponding to a remote TopGit branch,
1789 which lives under ``refs/remotes/`` somewhere (depending on
1790 what the output of ``tg --top-bases`` is for that remote).
1793 A three-way merge takes a common base and two heads (call them
1794 A and B) and creates a new file that is the common base plus
1795 all of the changes made between the common base and head A
1796 *AND* all of the changes made between the common base and
1797 head B. The technique used to accomplish this is called a
1804 The following references are useful to understand the development of
1805 topgit and its subcommands.
1808 http://public-inbox.org/git/36ca99e90904091034m4d4d31dct78acb333612e678@mail.gmail.com/T/#u
1811 THIRD-PARTY SOFTWARE
1812 --------------------
1814 The following software understands TopGit branches:
1816 * `magit <http://magit.github.io/>`_ -- a git mode for emacs
1818 IMPORTANT: Magit requires its topgit mode to be enabled first, as
1819 described in its documentation, in the "Activating extensions"
1820 subsection. If this is not done, it will not push TopGit branches
1821 correctly, so it's important to enable it even if you plan to mostly use
1822 TopGit from the command line.