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 To use TopGit with linked working trees (the ``git worktree add`` command),
34 at least Git version 2.5.0 (obviously, since that's when the ``git worktree``
35 command first appeared) is needed in which case linked working trees are then
36 fully supported for use with TopGit.
38 The scripts need to be preprocessed and installed and currently the Makefile
39 that does this requires GNU make, but that's an install-time-only requirement.
41 It is possible, however, to use the DESTDIR functionality to install TopGit to
42 a staging area on one machine, archive that and then unarchive it on another
43 machine to perform an install (provided the build prefix and other options are
44 compatible with the final installed location).
50 See the file ``INSTALL``.
56 The TopGit git repository can be found at <http://repo.or.cz/topgit/pro>.
62 Why not use something like StGIT or Guilt or ``rebase -i`` for maintaining
63 your patch queue? The advantage of these tools is their simplicity;
64 they work with patch *series* and defer to the reflog facility for
65 version control of patches (reordering of patches is not
66 version-controlled at all). But there are several disadvantages -- for
67 one, these tools (especially StGIT) do not actually fit well with plain
68 Git at all: it is basically impossible to take advantage of the index
69 effectively when using StGIT. But more importantly, these tools
70 horribly fail in the face of a distributed environment.
72 TopGit has been designed around three main tenets:
74 (i) TopGit is as thin a layer on top of Git as possible. You
75 still maintain your index and commit using Git; TopGit will only
76 automate a few indispensable tasks.
78 (ii) TopGit is anxious about *keeping* your history. It will
79 never rewrite your history, and all metadata is also tracked
80 by Git, smoothly and non-obnoxiously. It is good to have a
81 *single* point when the history is cleaned up, and that is at
82 the point of inclusion in the upstream project; locally, you
83 can see how your patch has evolved and easily return to older
86 (iii) TopGit is specifically designed to work in a
87 distributed environment. You can have several instances of
88 TopGit-aware repositories and smoothly keep them all
89 up-to-date and transfer your changes between them.
91 As mentioned above, the main intended use-case for TopGit is tracking
92 third-party patches, where each patch is effectively a single topic
93 branch. In order to flexibly accommodate even complex scenarios when
94 you track many patches where many are independent but some depend on
95 others, TopGit ignores the ancient Quilt heritage of patch series and
96 instead allows the patches to freely form graphs (DAGs just like Git
97 history itself, only "one level higher"). For now, you have to manually
98 specify which patches the current one depends on, but TopGit might help
99 you with that in the future in a darcs-like fashion.
101 A glossary_ plug: The union (i.e. merge) of patch dependencies is called
102 a *base* of the patch (topic branch).
104 Of course, TopGit is perhaps not the right tool for you:
106 (i) TopGit is not complicated, but StGIT et al. are somewhat
107 simpler, conceptually. If you just want to make a linear
108 purely-local patch queue, deferring to StGIT instead might
111 (ii) When using TopGit, your history can get a little hairy
112 over time, especially with all the merges rippling through.
121 ## Create and evolve a topic branch
122 $ tg create t/gitweb/pathinfo-action
123 tg: Automatically marking dependency on master
124 tg: Creating t/gitweb/pathinfo-action base from master...
130 ## Create another topic branch on top of the former one
131 $ tg create t/gitweb/nifty-links
132 tg: Automatically marking dependency on t/gitweb/pathinfo-action
133 tg: Creating t/gitweb/nifty-links base from t/gitweb/pathinfo-action...
137 ## Create another topic branch on top of master and submit
138 ## the resulting patch upstream
139 $ tg create t/revlist/author-fixed master
140 tg: Creating t/revlist/author-fixed base from master...
144 tg: Sent t/revlist/author-fixed
146 To: git@vger.kernel.org
147 Cc: gitster@pobox.com
148 Subject: [PATCH] Fix broken revlist --author when --fixed-string
150 ## Create another topic branch depending on two others non-trivially
151 $ tg create t/whatever t/revlist/author-fixed t/gitweb/nifty-links
152 tg: Creating t/whatever base from t/revlist/author-fixed...
153 tg: Merging t/whatever base with t/gitweb/nifty-links...
155 tg: Please commit merge resolution and call: tg update --continue
156 tg: It is also safe to abort this operation using `git reset --hard`
157 tg: but please remember you are on the base branch now;
158 tg: you will want to switch to a different branch.
161 $ tg update --continue
165 ## Update a single topic branch and propagate the changes to
167 $ git checkout t/gitweb/nifty-links
170 $ git checkout t/whatever
172 Topic Branch: t/whatever (1 commit)
173 Subject: [PATCH] Whatever patch
175 Depends: t/revlist/author-fixed t/gitweb/nifty-links
177 t/gitweb/nifty-links (1 commit)
179 tg: Updating base with t/gitweb/nifty-links changes...
181 tg: Please commit merge resolution and call `tg update --continue`
182 tg: (use `tg status` to see more options)
185 $ tg update --continue
186 tg: Updating t/whatever against new base...
188 tg: Please commit merge resolution and call `tg update --continue`
189 tg: (use `tg status` to see more options)
192 $ tg update --continue
194 ## Update a single topic branch and propagate the changes
195 ## further through the dependency chain
196 $ git checkout t/gitweb/pathinfo-action
199 $ git checkout t/whatever
201 Topic Branch: t/whatever (1/2 commits)
202 Subject: [PATCH] Whatever patch
204 Depends: t/revlist/author-fixed t/gitweb/nifty-links
206 t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
208 tg: Recursing to t/gitweb/nifty-links...
209 [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
211 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
212 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
215 $ tg update --continue
216 [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base...
218 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
219 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
222 $ tg update --continue
223 tg: Updating base with t/gitweb/nifty-links changes...
224 tg: Updating t/whatever against new base...
226 ## Clone a TopGit-controlled repository
229 $ tg remote --populate origin
234 ## Add a TopGit remote to a repository and push to it
235 $ git remote add foo URL
239 ## Update from a non-default TopGit remote
248 When using TopGit there are several common conventions used when working with
249 TopGit branches. None of them are enforced, they are only suggestions.
251 There are three typical uses for a TopGit branch:
254 Normal TopGit branches that represent a single patch. These are known
255 as "patch" TopGit branches.
257 Empty TopGit branches with no dependencies (an empty ``.topdeps`` file)
258 that represent a base upon which other "normal" TopGit branches depend.
259 These are known as "base" TopGit branches (not to be confused with
260 the refs/top-bases/... refs).
262 Empty TopGit branches that serve as a staging area to bring together
263 several other TopGit branches into one place so they can be used/tested
264 all together. These are known as "stage" TopGit branches.
266 An "empty" TopGit branch is one that does not have any changes of its own --
267 it may still have dependencies though ("stage" branches do, "base" branches do
268 not). The ``tg summary`` output shows empty branches with a ``0`` in the
269 listing. Normal "patch" branches that have not been annihilated, "base" and
270 "stage" branches fall into this category. (Annihilated branches are normally
271 omitted from the ``tg summary`` output but can be shown if given explicitly as
272 an argument to the ``tg summary`` command. However, the message line will be
273 incorrect since an annihilated branch has no ``.topmsg`` file of its own.)
275 A "patch" branch name typically starts with ``t/`` whereas "base" and "stage"
276 branch names often do not.
278 A "base" branch is created by using the ``--no-deps`` option of ``tg create``
279 which will automatically suggest a "[BASE]" message prefix rather than
280 "[PATCH]". A "stage" branch is created like a normal patch branch except that
281 the only changes that will ever be made to it are typically to add/remove
282 dependencies. Its subject prefix must be manually changed to "[STAGE]" to
285 Since both "base" and "stage" branches typically only have a use for the
286 "Subject:" ilne from their ``.topmsg`` file, they are quite easily created
287 using the ``--topmsg`` option of ``tg create``.
289 Use of "stage" and "base" branches is completely optional. However, without
290 use of a "stage" branch it will be difficult to test multiple independent
291 patches together all at once. A "base" branch is merely a convenience that
292 provides more explicit control over when a common base for a set of patches
293 gets updated as well as providing a branch that shows in ``tg summary`` output
294 and participates in ``tg remote --populate`` setup.
296 When using the ``tg tag`` command to create tags that record the current state
297 of one or more TopGit branches, the tags are often created with a name that
300 One last thing, you have enabled ``git rerere`` haven't you?
306 Beware, there is no "undo" after running a ``tg update``!
308 Well, that's not entirely correct. Since ``tg update`` never discards commits
309 an "undo" operation is technically feasible provided the old values of all the
310 refs that were affected by the ``tg update`` operation can be determined and
311 then they are simply changed back to their previous values.
313 In practice though, it can be extremely tedious and error prone looking through
314 log information to try and determine what the correct previous values were.
315 Although, since TopGit tries to make sure reflogs are enabled for top-bases
316 refs, using Git's ``@{date}`` notation on all the refs dumped out by a
317 ``tg tag --refs foo``, where "foo" is the branch that was updated whose update
318 needs to be undone, may work.
320 Alternatively, ``tg tag --stash`` can be used prior to the update and then
321 ``tg revert`` used after the update to restore the previous state. This
322 assumes, of course, that you remember to run ``tg tag --stash`` first.
324 The ``tg update`` command understands a ``--stash`` option that tells it to
325 automatically run ``tg tag --stash`` before it starts making changes (if
326 everything is up-to-date it won't run the stash command at all).
328 The ``--stash`` option is the default nowadays when running ``tg update``,
329 add the ``--no-stash`` option to turn it off.
331 There is a preference for this. Setting the config value ``topgit.autostash``
332 to ``false`` will implicitly add the ``--no-stash`` option to any ``tg update``
333 command unless an explicit ``--stash`` option is given.
335 If you are likely to ever want to undo a ``tg update``, setting
336 ``topgit.autostash`` to ``false`` is highly discouraged!
338 Note that the tags saved by ``tg tag --stash`` are stored in the
339 ``refs/tgstash`` ref and its reflog. Unfortunately, while Git is happy to
340 maintain the reflog (once it's been enabled which ``tg tag`` guarantees for
341 ``refs/tgstash``), Git is unable to view an annotated/signed tag's reflog!
342 Instead Git dereferences the tag and shows the wrong thing. Use the
343 ``tg tag -g`` command to view the ``refs/tgstash`` reflog instead.
349 No, this is not a section about budget nonsense. ;)
351 TopGit keeps its metadata in ``.topdeps`` and ``.topmsg`` files. In an effort
352 to facilitate cherry-picking and other Git activities on the patch changes
353 themselves while ignoring the TopGit metadata, TopGit attempts to keep all
354 changes to ``.topdeps`` and ``.topmsg`` files limited to commits that do NOT
355 contain changes to any other files.
357 This is a departure from previous TopGit versions that made no such effort.
359 Primarily this affects ``tg create`` and ``tg import`` (which makes use of
360 ``tg create``) as ``tg create`` will commit the initial versions of
361 ``.topdeps`` and ``.topmsg`` for a new TopGit-controlled branch in their own
362 commit instead of mixing them in with changes to other files.
364 The ``pre-commit`` hook will also attempt to separate out any ``.topdeps`` and
365 ``.topmsg`` changes from commits that include changes to other files.
367 It is possible to defeat these checks without much effort (``pre-commit`` hooks
368 can easily be bypassed, ``tg create`` has a ``--no-commit`` option, many Git
369 commands simply do not run the ``pre-commit`` hook, etc.).
371 If you really, really, really, really want to change the default back to the
372 old behavior of previous TopGit versions where no such sequestration took
373 place, then set the ``topgit.sequester`` config variable explicitly to the
374 value ``false``. But this is not recommended.
377 AMENDING AND REBASING AND UPDATE-REF'ING
378 ----------------------------------------
382 It is okay to manually update a top-bases/... ref when a) it has no depedencies
383 (i.e. it was created with the ``tg create`` ``--no-deps`` option) and b) the
384 old top-bases/... ref value can be fast-forwarded to the new top-bases/...
385 value OR the new value contains ALL of the changes in the old value through
386 some other mechanism (perhaps they were cherry-picked or otherwise applied to
387 the new top-bases/... ref). The same rules apply to non-TopGit-controlled
390 Ignoring this rule and proceeding anyway with a non-fast-forward update to a
391 top-bases/... ref will result in changes present in the new value being merged
392 into the branch (at ``tg update`` time) as expected (possibly with conflicts),
393 but any changes that were contained in the old version of the top-bases/... ref
394 which have been dropped (i.e. are NOT contained in the new version of the
395 top-bases/... ref) will continue to be present in the branch! To get rid of
396 the dropped commits, one or more "revert" commits will have to be manually
397 applied to the tip of the new top-bases/... value (which will then be merged
398 into the branch at next ``tg update`` time).
400 The only time it's safe to amend, rebase, filter or otherwise rewrite commits
401 contained in a TopGit controlled branch or non-TopGit branch is when those
402 commits are NOT reachable via any other ref!
404 Furthermore, while it is safe to rewrite merge commits (provided they meet the
405 same conditions) the merge commits themselves and the branches they are merging
406 in must be preserved during the rewrite and that can be rather tricky to get
407 right so it's not recommended.
409 For example, if, while working on a TopGit-controlled branch ``foo``, a bad
410 typo is noticed, it's okay to ammend/rebase to fix that provided neither
411 ``tg update`` nor ``tg create`` has already been used to cause some other ref
412 to be able to reach the commit with the typo.
414 If an amend or rerwite is done anyway even though the commit with the typo is
415 reachable from some other ref, the typo won't really be removed. What will
416 happen instead is that the new version without the typo will ultimately be
417 merged into the other ref(s) (at ``tg update`` time) likely causing a conflict
418 that will have to be manually resolved and the commit with the typo will
419 continue to be reachable from those other refs!
421 Instead just make a new commit to fix the typo. The end result will end up
422 being the same but without the merge conflicts.
424 See also the discussion in the `NO UNDO`_ section.
430 TopGit needs to check many things to determine whether a TopGit branch is
431 up-to-date or not. This can involve a LOT of git commands for a complex
432 dependency tree. In order to speed things up, TopGit keeps a cache of results
433 in a ``tg-cache`` subdirectory in the ``.git`` directory.
435 Results are tagged with the original hash values used to get that result so
436 that items which have not been changed return their results quickly and items
437 which have been changed compute their new result and cache it for future use.
439 The ``.git/tg-cache`` directory may be removed at any time and the cache will
440 simply be recreated in an on-demand fashion as needed, at some speed penalty,
441 until it's fully rebuilt.
443 To force the cache to be fully pre-loaded, run the ``tg summary`` command
444 without any arguments. Otherwise, normal day-to-day TopGit operations should
445 keep it more-or-less up-to-date.
447 While each TopGit command is running, it uses a temporary subdirectory also
448 located in the ``.git`` directory. These directories are named
449 ``tg-tmp.XXXXXX`` where the ``XXXXXX`` part will be random letters and digits.
451 These temporary directories should always be removed automatically after each
452 TopGit command finishes running. As long as you are not in a subshell as a
453 result of a TopGit command stopping and waiting for a manual merge resolution,
454 it's safe to remove any of these directories that may have somehow accidentally
455 been left behind as a result of some failure that occurred while running a
456 TopGit command (provided, of course, it's not actually being used by a TopGit
457 command currently running in another terminal window or by another user on the
463 ``tg [-C <dir>] [-r <remote> | -u] [-c <name>=<val>] <subcommand> [<subcommand option/argument>...]``
465 -C <dir> Change directory to <dir> before doing anything
466 -r <remote> Pretend ``topgit.remote`` is set to <remote>
467 -u Pretend ``topgit.remote`` is not set
468 -c <name=val> Pass config option to git, may be repeated
470 The ``tg`` tool has several subcommands:
472 :`tg annihilate`_: Mark a TopGit-controlled branch as defunct
473 :`tg base`_: Show base commit for one or more TopGit branches
474 :`tg checkout`_: Shortcut for git checkout with name matching
475 :`tg contains`_: Which TopGit-controlled branch contains the commit
476 :`tg create`_: Create a new TopGit-controlled branch
477 :`tg delete`_: Delete a TopGit-controlled branch cleanly
478 :`tg depend`_: Add a new dependency to a TopGit-controlled branch
479 :`tg export`_: Export TopGit branch patches to files or a branch
480 :`tg files`_: Show files changed by a TopGit branch
481 :`tg help`_: Show TopGit help optionally using a browser
482 :`tg import`_: Import commit(s) to separate TopGit branches
483 :`tg info`_: Show status information about a TopGit branch
484 :`tg log`_: Run git log limiting revisions to a TopGit branch
485 :`tg mail`_: Shortcut for git send-email with ``tg patch`` output
486 :`tg migrate-bases`_: Transition top-bases to new location
487 :`tg next`_: Show branches directly depending on a TopGit branch
488 :`tg patch`_: Generate a patch file for a TopGit branch
489 :`tg prev`_: Show non-annihilated TopGit dependencies for a branch
490 :`tg push`_: Run git push on TopGit branch(es) and depedencies
491 :`tg rebase`_: Auto continue git rebase if rerere resolves conflicts
492 :`tg remote`_: Set up remote for fetching/pushing TopGit branches
493 :`tg revert`_: Revert ref(s) to a state stored in a ``tg tag``
494 :`tg status`_: Show current TopGit status (e.g. in-progress update)
495 :`tg summary`_: Show various information about TopGit branches
496 :`tg tag`_: Create tag that records current TopGit branch state
497 :`tg update`_: Update TopGit branch(es) with respect to dependencies
501 Our sophisticated integrated help facility. Mostly duplicates
506 # to get help for a particular command:
508 # to get help for a particular command in a browser window:
509 $ tg help -w <command>
510 # to get help on TopGit itself
512 # to get help on TopGit itself in a browser
517 Our sophisticated status facility. Similar to Git's status command
518 but shows any in-progress update that's awaiting a merge resolution
519 or any other on-going TopGit activity (such as a branch creation).
521 With a single ``--verbose`` (or ``-v``) option include a short status
522 display for any dirty (but not untracked) files. This also causes all
523 non file status lines to be prefixed with "## ".
525 With two (or more) ``--verbose`` (or ``-v``) options, additionally
526 show full symbolic ref names and unabbreviated hash values.
528 With the ``--exit-code`` option the exit code will be non-zero if any
529 TopGit or Git operation is currently in progress or the working
534 Create a new TopGit-controlled topic branch of the given name
535 (required argument) and switch to it. If no dependencies are
536 specified (by extra arguments passed after the first one), the
537 current branch is assumed to be the only dependency.
539 By default ``tg create`` opens an editor on the new ``.topmsg`` file
540 and then commits the new ``.topmsg`` and ``.topdeps`` files
541 automatically with a suitable default commit message.
543 The commit message can be changed with the ``-m`` (or ``--message``) or
544 ``-F`` (or ``--file``) option. The automatic commit can be suppressed
545 by using the ``--no-ccmmit`` option. Running the editor on the new
546 ``.topmsg`` file can be suppressed by using ``-n`` (or ``--no-edit``)
547 (which also suppresses the automatic commit) or by providing an
548 explicit value for the new ``.topmsg`` file using the ``--topmsg`` or
549 ``--topmsg-file`` option. In any case the ``.topmsg`` content will be
550 automatically reformated to have a ``Subject:`` header line if needed.
552 If more than one dependency is listed, the automatic commit will not
553 take place until AFTER all the listed dependencies have been merged
554 into a base commit which will require some manual merge resolutions if
555 conflicts occur during the merge operations.
557 Previous versions of TopGit behaved as though the ``--no-edit`` option
558 was always given on the command line.
560 The default behavior has been changed to promote a separation between
561 commits that modify ``.topmsg`` and/or ``.topdeps`` and commits that
562 modify other files. This facilitates cleaner cherry picking and other
563 patch maintenance activities.
565 You should edit the patch description (contained in the ``.topmsg``
566 file) as appropriate. It will already contain some prefilled bits.
567 You can set the ``topgit.to``, ``topgit.cc`` and ``topgit.bcc``
568 git configuration variables (see ``man git-config``) in order to
569 have ``tg create`` add these headers with the given default values
570 to ``.topmsg`` before invoking the editor.
572 The main task of ``tg create`` is to set up the topic branch base
573 from the dependencies. This may fail due to merge conflicts if more
574 than one dependency is given. In that case, after you commit the
575 conflict resolution, you should call ``tg update --continue`` to
576 finish merging the dependencies into the new topic branch base.
578 With the ``--no-deps`` option at most one dependency may be listed
579 which may be any valid committish (instead of just refs/heads/...) and
580 the newly created TopGit-controlled branch will have an empty
581 ``.topdeps`` file. This may be desirable in order to create a TopGit-
582 controlled branch that has no changes of its own and serves merely to
583 mark the common dependency that all other TopGit-controlled branches
584 in some set of TopGit-controlled branches depend on. A plain,
585 non-TopGit-controlled branch can be used for the same purpose, but the
586 advantage of a TopGit-controlled branch with no dependencies is that it
587 will be pushed with ``tg push``, it will show up in the ``tg summary``
588 and ``tg info`` output with the subject from its ``.topmsg`` file
589 thereby documenting what it's for and finally it can be set up with
590 ``tg create -r`` and/or ``tg remote --populate`` to facilitate sharing.
592 For example, ``tg create --no-deps release v2.1`` will create a TopGit-
593 controlled ``release`` branch based off the ``v2.1`` tag that can then
594 be used as a base for creation of other TopGit-controlled branches.
595 Then when the time comes to move the base for an entire set of changes
596 up to ``v2.2`` the command ``git update-ref top-bases/release v2.2^0``
597 can be used followed by ``tg update --all``. Note that it's only safe
598 to update ``top-bases/release`` directly in this manner because a) it
599 has no depedencies since it was created with the ``--no-deps`` option
600 and b) the old ``top-bases/release`` value can be fast-forwarded to the
601 new ``top-bases/release`` value.
603 Using ``--no-deps`` it's also possible to use ``tg create`` on an
604 unborn branch (omit the dependency name or specify ``HEAD``). The
605 unborn branch itself can be made into the new TopGit branch (rather
606 than being born empty and then having the new TopGit branch based off
607 that) by specifying ``HEAD`` as the new branch's name (which is
608 probably what you normally want to do in this case anyway so you can
609 just run ``tg create --no-deps HEAD`` to accomplish that).
611 In an alternative use case, if ``-r <branch>`` is given instead of a
612 dependency list, the topic branch is created based on the given
613 remote branch. With just ``-r`` the remote branch name is assumed
614 to be the same as the local topic branch being created. Since no
615 new commits are created in this mode (only two refs will be updated)
616 the editor will never be run for this use case. Note that no other
617 options may be combined with ``-r``.
619 The ``--quiet`` (or ``-q``) option suppresses most informational
624 Remove a TopGit-controlled topic branch of the given name
625 (required argument). Normally, this command will remove only an
626 empty branch (base == head) without dependendents; use ``-f`` to
627 remove a non-empty branch or a branch that is depended upon by
630 The ``-f`` option is also useful to force removal of a branch's
631 base, if you used ``git branch -D B`` to remove branch B, and then
632 certain TopGit commands complain, because the base of branch B
635 Normally ``tg delete`` will refuse to delete the current branch.
636 However, giving ``-f`` twice (or more) will force it to do so but it
637 will first detach your HEAD.
639 IMPORTANT: Currently, this command will *NOT* remove the branch
640 from the dependency list in other branches. You need to take
641 care of this *manually*. This is even more complicated in
642 combination with ``-f`` -- in that case, you need to manually
643 unmerge the removed branch's changes from the branches depending
646 See also ``tg annihilate``.
648 | TODO: ``-a`` to delete all empty branches, depfix, revert
652 Make a commit on the current TopGit-controlled topic branch
653 that makes it equal to its base, including the presence or
654 absence of .topmsg and .topdeps. Annihilated branches are not
655 displayed by ``tg summary``, so they effectively get out of your
656 way. However, the branch still exists, and ``tg push`` will
657 push it (except if given the ``-a`` option). This way, you can
658 communicate that the branch is no longer wanted.
660 When annihilating a branch that has dependents (i.e. branches
661 that depend on it), those dependents have the dependencies of
662 the branch being annihilated added to them if they do not already
663 have them as dependencies. Essentially the DAG is repaired to
664 skip over the annihilated branch.
666 Normally, this command will remove only an empty branch
667 (base == head, except for changes to the .top* files); use
668 ``-f`` to annihilate a non-empty branch.
670 After completing the annihilation itself, normally ``tg update``
671 is run on any modified dependents. Use the ``--no-update`` option
672 to suppress running ``tg update``.
676 Change the dependencies of a TopGit-controlled topic branch.
677 This should have several subcommands, but only ``add`` is
680 The ``add`` subcommand takes an argument naming a topic branch to
681 be added, adds it to ``.topdeps``, performs a commit and then
682 updates your topic branch accordingly. If you want to do other
683 things related to the dependency addition, like adjusting
684 ``.topmsg``, use the option ``--no-commit``. Adding the
685 ``--no-update`` (or ``--no-commit``) option will suppress the
686 ``tg update`` normally performed after committing the change.
688 It is safe to run ``tg depend add`` in a dirty worktree, but the
689 normally performed ``tg update`` will be suppressed in that case
690 (even if neither ``--no-update`` nor ``--no-commit`` is given).
692 You have enabled ``git rerere`` haven't you?
694 | TODO: Subcommand for removing dependencies, obviously
698 List files changed by the current or specified topic branch.
701 -i list files based on index instead of branch
702 -w list files based on working tree instead of branch
706 Show summary information about the current or specified topic
709 Numbers in parenthesis after a branch name such as "(11/3 commits)"
710 indicate how many commits on the branch (11) and how many of those
711 are non-merge commits (3).
713 With ``--verbose`` (or ``-v``) include a list of dependents (i.e. other
714 branches that depend on this one). Another ``--verbose`` annotates
715 them with "[needs merge]" if the current tip of branch for which info
716 is being shown has not yet been merged into the base of the dependent.
718 Alternatively, if ``--heads`` is used then which of the independent
719 TopGit branch heads (as output by ``tg summary --topgit-heads``)
720 logically contains the specified commit (which may be any committish --
721 defaults to ``HEAD`` if not given). Zero or more results will be
722 output. Note that "logically" means with regard to the TopGit
723 dependency relationships as established by the ``.topdeps`` file(s).
724 It's the answer that would be given when all the TopGit branches are
725 up-to-date (even though they need not be to use this option) and the
726 ``git branch --contains`` command is run and the output then filtered
727 to only those branches that appear in ``tg summary --topgit-heads``.
728 This computation may require several seconds on complex repositories.
730 If ``--leaves`` is used then the unique list of leaves of the current
731 or specified topic branch is shown as one fully-qualified ref per line.
732 Duplicates are suppressed and a tag name will be used when appropriate.
733 A "leaf" is any dependency that is either not a TopGit branch or is
734 the base of a non-annihilated TopGit branch with no non-annihilated
737 A linearized patch series can only be automatically created for a
738 TopGit topic branch (including its recursive dependencies) when exactly
739 one line is output by ``tg info --leaves <topic-branch>``.
743 Generate a patch from the current or specified topic branch.
744 This means that the diff between the topic branch base and head
745 (latest commit) is shown, appended to the description found in
746 the ``.topmsg`` file.
748 The patch is simply dumped to stdout. In the future, ``tg patch``
749 will be able to automatically send the patches by mail or save
750 them to files. (TODO)
753 -i base patch generation on index instead of branch
754 -w base patch generation on working tree instead of branch
755 --binary pass --binary to ``git diff-tree`` to enable generation
757 --diff-opt options after the branch name (and an optional ``--``)
758 are passed directly to ``git diff-tree``
760 In order to pass a sole explicit ``-w`` through to ``git diff-tree`` it
761 must be separated from the ``tg`` options by an explicit ``--``.
762 Or it can be spelled as ``--ignore-all-space`` to distinguuish it from
763 ``tg``'s ``-w`` option.
765 If additional non-``tg`` options are passed through to
766 ``git diff-tree`` (other than ``--binary`` which is fully supported)
767 the resulting ``tg patch`` output may not be appliable.
771 Send a patch from the current or specified topic branch as
774 Takes the patch given on the command line and emails it out.
775 Destination addresses such as To, Cc and Bcc are taken from the
778 Since it actually boils down to ``git send-email``, please refer
779 to the documentation for that for details on how to setup email
780 for git. You can pass arbitrary options to this command through
781 the ``-s`` parameter, but you must double-quote everything. The
782 ``-r`` parameter with a msgid can be used to generate in-reply-to
783 and reference headers to an earlier mail.
785 WARNING: be careful when using this command. It easily sends
786 out several mails. You might want to run::
788 git config sendemail.confirm always
790 to let ``git send-email`` ask for confirmation before sending any
794 -i base patch generation on index instead of branch
795 -w base patch generation on working tree instead of branch
797 | TODO: ``tg mail patchfile`` to mail an already exported patch
798 | TODO: mailing patch series
799 | TODO: specifying additional options and addresses on command line
803 Register the given remote as TopGit-controlled. This will create
804 the namespace for the remote branch bases and teach ``git fetch``
805 to operate on them. However, from TopGit 0.8 onwards you need to
806 use ``tg push``, or ``git push --mirror``, for pushing
807 TopGit-controlled branches.
809 ``tg remote`` takes an optional remote name argument, and an
810 optional ``--populate`` switch. Use ``--populate`` for your
811 origin-style remotes: it will seed the local topic branch system
812 based on the remote topic branches. ``--populate`` will also make
813 ``tg remote`` automatically fetch the remote, and ``tg update`` look
814 at branches of this remote for updates by default.
816 Using ``--populate`` with a remote name causes the ``topgit.remote``
817 git configuration variable to be set to the given remote name.
821 Show overview of all TopGit-tracked topic branches and their
822 up-to-date status. With a branch name limit output to that branch.
823 Using ``--deps-only`` or ``--rdeps`` changes the default from all
824 branches to just the current ``HEAD`` branch but using ``--all`` as
825 the branch name will show results for all branches instead of ``HEAD``.
828 marks the current topic branch
831 indicates that it introduces no changes of its own
834 indicates respectively whether it is local-only
838 indicates respectively if it is ahead or out-of-date
839 with respect to its remote mate
842 indicates that it is out-of-date with respect to its
846 indicates that it has missing dependencies [even if
847 they are recursive ones]
850 indicates that it is out-of-date with respect to
853 This can take a longish time to accurately determine all the
854 relevant information about each branch; you can pass ``-t`` (or ``-l``
855 or ``--list``) to get just a terse list of topic branch names quickly.
857 Passing ``--heads`` shows independent topic branch names and when
858 combined with ``--rdeps`` behaves as though ``--rdeps`` were run with
859 the output of ``--heads``.
861 The ``--heads-independent`` option works just like ``--heads`` except
862 that it computes the heads using ``git merge-base --independent``
863 rather than examining the TopGit ``.topdeps`` relationships. If the
864 TopGit branches are all up-to-date (as shown in ``tg summary``) then
865 both ``--heads`` and ``--heads-independent`` should compute the same
866 list of heads (unless some overlapping TopGit branches have been
867 manually created). If not all the TopGit branches are up-to-date then
868 the ``--heads-independent`` results may have extra items in it, but
869 occasionally that's what's needed; usually it's the wrong answer.
870 (Note that ``--topgit-heads`` is accepted as an alias for ``--heads``
873 Using ``--heads-only`` behaves as though the output of ``--heads`` was
874 passed as the list of branches along with ``--without-deps``.
876 Alternatively, you can pass ``--graphviz`` to get a dot-suitable output
877 for drawing a dependency graph between the topic branches.
879 You can also use the ``--sort`` option to sort the branches using
880 a topological sort. This is especially useful if each
881 TopGit-tracked topic branch depends on a single parent branch,
882 since it will then print the branches in the dependency order.
883 In more complex scenarios, a text graph view would be much more
884 useful, but that has not yet been implemented.
886 The ``--deps`` option outputs dependency information between
887 branches in a machine-readable format. Feed this to ``tsort`` to
888 get the output from --sort.
890 The ``--deps-only`` option outputs a sorted list of the unique branch
891 names given on the command line plus all of their recursive
892 dependencies (subject to ``--exclude`` of course). When
893 ``--deps-only`` is given the default is to just display information for
894 ``HEAD``, but that can be changed by using ``--all`` as the branch
895 name. Each branch name will appear only once in the output no matter
896 how many times it's visited while tracing the dependency graph or how
897 many branch names are given on the command line to process.
899 The ``--rdeps`` option outputs dependency information in an indented
900 text format that clearly shows all the dependencies and their
901 relationships to one another. When ``--rdeps`` is given the default is
902 to just display information for ``HEAD``, but that can be changed by
903 using ``--all`` as the branch name or by adding the ``--heads`` option.
904 Note that ``tg summary --rdeps --heads`` can be particularly helpful in
905 seeing all the TopGit-controlled branches in the repository and their
906 relationships to one another.
908 Adding ``--with-deps`` replaces the given list of branches (which will
909 default to ``HEAD`` if none are given) with the result of running
910 ``tg summary --deps-only --tgish`` on the list of branches. This can
911 be helpful in limiting ``tg summary`` output to only the list of given
912 branches and their dependencies when many TopGit-controlled branches
913 are present in the repository. When it would be allowed,
914 ``--with-deps`` is now the default. Use ``--without-deps`` to switch
915 back to the old behavior.
917 With ``--exclude branch``, branch can be excluded from the output
918 meaning it will be skipped and its name will be omitted from any
919 dependency output. The ``--exclude`` option may be repeated to omit
920 more than one branch from the output. Limiting the output to a single
921 branch that has been excluded will result in no output at all.
923 The ``--tgish-only`` option behaves as though any non-TopGit-controlled
924 dependencies encountered during processing had been listed after an
925 ``--exclude`` option.
927 Note that the branch name can be specified as ``HEAD`` or ``@`` as a
928 shortcut for the TopGit-controlled branch that ``HEAD`` is a
929 symbolic ref to. The ``tg summary @`` command can be quite useful.
932 -i Use TopGit metadata from the index instead of the branch
933 -w Use TopGit metadata from the working tree instead of the branch
937 Search all TopGit-controlled branches (and optionally their remotes)
938 to find which TopGit-controlled branch contains the specified commit.
940 This is more than just basic branch containment as provided for by the
941 ``git branch --contains`` command. While the shown branch name(s)
942 will, indeed, be one (or more) of those output by the
943 ``git branch --contains`` command, the result(s) will exclude any
944 TopGit-controlled branches from the result(s) that have one (or more)
945 of their TopGit dependencies (either direct or indirect) appearing in
946 the ``git branch --contains`` output.
948 Normally the result will be only the one, single TopGit-controlled
949 branch for which the specified committish appears in the ``tg log``
950 output for that branch (unless the committish lies outside the
951 TopGit-controlled portion of the DAG and ``--no-strict`` was used).
953 Unless ``--annihilated-okay`` (or ``--ann`` or ``--annihilated``) is
954 used then annihilated branches will be immediately removed from the
955 ``git branch --contains`` output before doing anything else. This
956 means a committish that was originally located in a now-annihilated
957 branch will show up in whatever branch picked up the annihilated
958 branch's changes (if there is one). This is usually the correct
959 answer, but occasionally it's not; hence this option. If this option
960 is used together with ``--verbose`` then annihilated branches will
961 be shown as "[:annihilated:]".
963 In other words, if a ``tg patch`` is generated for the found branch
964 (assuming one was found and a subsequent commit in the same branch
965 didn't then revert or otherwise back out the change), then that patch
966 will include the changes introduced by the specified committish
967 (unless, of course, that committish is outside the TopGit-controlled
968 portion of the DAG and ``--no-strict`` was given).
970 This can be very helpful when, for example, a bug is discovered and
971 then after using ``git bisect`` (or some other tool) to find the
972 offending commit it's time to commit the fix. But because the
973 TopGit merging history can be quite complicated and maybe the one
974 doing the fix wasn't the bug's author (or the author's memory is just
975 going), it can sometimes be rather tedious to figure out which
976 TopGit branch the fix belongs in. The ``tg contains`` command can
977 quickly tell you the answer to that question.
979 With the ``--remotes`` (or ``-r``) option a TopGit-controlled remote
980 branch name may be reported as the result but only if there is no
981 non-remote branch containing the committish (this can only happen
982 if at least one of the TopGit-controlled local branches are not yet
983 up-to-date with their remotes).
985 With the ``--verbose`` option show which TopGit DAG head(s) (one or
986 more of the TopGit-controlled branch names output by
987 ``tg summary --heads``) have the result as a dependency (either direct
988 or indirect). Using this option will noticeably increase running time.
990 With the default ``--strict`` option, results for which the base of the
991 TopGit-controlled branch contains the committish will be suppressed.
992 For example, if the committish was deep-down in the master branch
993 history somewhere far outside of the TopGit-controlled portion of
994 the DAG, with ``--no-strict``, whatever TopGit-controlled branch(es)
995 first picked up history containing that committish will be shown.
996 While this is a useful result it's usually not the desired result
997 which is why it's not the default.
999 To summarize, even with ``--remotes``, remote results are only shown
1000 if there are no non-remote results. Without ``--no-strict`` (because
1001 ``--strict`` is the default) results outside the TopGit-controlled
1002 portion of the DAG are never shown and even with ``--no-strict`` they
1003 will only be shown if there are no ``--strict`` results. Finally,
1004 the TopGit head info shown with ``--verbose`` only ever appears for
1005 local (i.e. not a remote branch) results. Annihilated branches are
1006 never considered possible matches without ``--annihilated-okay``.
1010 Switch to a topic branch. You can use ``git checkout <branch>``
1011 to get the same effect, but this command helps you navigate
1012 the dependency graph, or allows you to match the topic branch
1013 name using a regular expression, so it can be more convenient.
1015 There following subcommands are available:
1017 ``tg checkout push``
1018 Check out a branch that directly
1019 depends on your current branch.
1022 Check out a branch that this branch
1023 directly depends on.
1025 ``tg checkout [goto] [--] <pattern>``
1026 Check out a topic branch that
1027 matches ``<pattern>``. ``<pattern>``
1028 is used as a sed pattern to filter
1029 all the topic branches. Both ``goto`` and
1030 ``--`` may be omitted provided ``<pattern>``
1031 is not ``push``, ``pop``, ``-a``, ``--all``,
1032 ``goto``, ``..``, ``--``, ``next``, ``child``,
1033 ``prev``, ``parent``, ``-h`` or ``--help``.
1035 ``tg checkout next``
1036 An alias for ``push``.
1038 ``tg checkout child``
1039 An alias for ``push``.
1042 An alias for ``push``.
1044 ``tg checkout prev``
1045 An alias for ``pop``.
1047 ``tg checkout parent``
1048 An alias for ``pop``.
1051 An alias for ``pop``.
1053 If any of the above commands can find more than one possible
1054 branch to switch to, you will be presented with the matches
1055 and asked to select one of them.
1057 If the ``--ignore-other-worktrees`` (or ``--iow``) option is given and
1058 the current Git version is at least 2.5.0 then the full
1059 ``--ignore-other-worktrees`` option will be passed along to the
1060 ``git checkout`` command when it's run (otherwise the option will be
1061 silently ignored and not passed to Git as it would cause an error).
1063 The ``--force`` (or ``-f``) option, when given, gets passed through to
1064 the ``git checkout`` command.
1066 The ``<pattern>`` of ``tg checkout goto`` is optional. If you don't
1067 supply it, all the available topic branches are listed and you
1068 can select one of them.
1070 Normally, the ``push`` and ``pop`` commands moves one step in
1071 the dependency graph of the topic branches. The ``-a`` option
1072 causes them (and their aliases) to move as far as possible.
1073 That is, ``tg checkout push -a`` moves to a topic branch that
1074 depends (directly or indirectly) on the current branch and
1075 that no other branch depends on. ``tg checkout pop -a``
1076 moves to a regular branch that the current topic branch
1077 depends on (directly or indirectly). If there is more than
1078 one possibility, you will be prompted for your selection.
1082 Export a tidied-up history of the current topic branch and its
1083 dependencies, suitable for feeding upstream. Each topic branch
1084 corresponds to a single commit or patch in the cleaned up
1085 history (corresponding basically exactly to ``tg patch`` output
1086 for the topic branch).
1088 The command has three possible outputs now -- either a Git branch
1089 with the collapsed history, a Git branch with a linearized
1090 history, or a quilt series in new directory.
1092 In the case where you are producing collapsed history in a new
1093 branch, you can use this collapsed structure either for
1094 providing a pull source for upstream, or for further
1095 linearization e.g. for creation of a quilt series using git log::
1097 git log --pretty=email -p --topo-order origin..exported
1099 To better understand the function of ``tg export``, consider this
1100 dependency structure::
1102 origin/master - t/foo/blue - t/foo/red - master
1103 `- t/bar/good <,----------'
1104 `- t/baz ------------'
1106 (where each of the branches may have a hefty history). Then::
1108 master$ tg export for-linus
1110 will create this commit structure on the branch ``for-linus``::
1112 origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
1113 `- t/bar/good <,-------------------'/
1114 `- t/baz ---------------------'
1116 In this mode, ``tg export`` works on the current topic branch, and
1117 can be called either without an option (in that case,
1118 ``--collapse`` is assumed), or with the ``--collapse`` option, and
1119 with one mandatory argument: the name of the branch where the
1120 exported result will be stored.
1122 When using the linearize mode::
1124 master$ tg export --linearize for-linus
1126 you get a linear history respecting the dependencies of your
1127 patches in a new branch ``for-linus``. The result should be more
1128 or less the same as using quilt mode and then reimporting it
1129 into a Git branch. (More or less because the topological order
1130 can usually be extended in more than one way into a total order,
1131 and the two methods may choose different ones.) The result
1132 might be more appropriate for merging upstream, as it contains
1135 Note that you might get conflicts during linearization because
1136 the patches are reordered to get a linear history. If linearization
1137 would produce conflicts then using ``--quilt`` will also likely result
1138 in conflicts when the exported quilt series is applied. Since the
1139 ``--quilt`` mode simply runs a series of ``tg patch`` commands to
1140 generate the patches in the exported quilt series and those patches
1141 will end up being applied linearly, the same conflicts that would be
1142 produced by the ``--linearize`` option will then occur at that time.
1144 To avoid conflicts produced by ``--linearize`` (or by applying the
1145 ``--quilt`` output), use the default ``--collapse`` mode and then use
1146 ``tg rebase`` (or ``git rebase -m`` directly) on the collapsed branch
1147 (with a suitable <upstream>) followed by ``git format-patch`` on the
1148 rebased result to produce a conflict-free patch set. A suitable
1149 upstream may be determined with the ``tg info --leaves`` command (if
1150 it outputs more than one line, linearization will be problematic).
1152 You have enabled ``git rerere`` haven't you?
1154 When using the quilt mode::
1156 master$ tg export --quilt for-linus
1158 would create the following directory ``for-linus``::
1160 for-linus/t/foo/blue.diff
1161 for-linus/t/foo/red.diff
1162 for-linus/t/bar/good.diff
1163 for-linus/t/baz.diff
1170 With ``--quilt``, you can also pass the ``-b`` parameter followed
1171 by a comma-separated explicit list of branches to export, or
1172 the ``--all`` parameter (which can be shortened to ``-a``) to
1173 export them all. The ``--binary`` option enables producing Git
1174 binary patches. These options are currently only supported
1177 In ``--quilt`` mode the patches are named like the originating
1178 topgit branch. So usually they end up in subdirectories of the
1179 output directory. With the ``--flatten`` option the names are
1180 mangled so that they end up directly in the output dir (slashes
1181 are replaced with underscores). With the ``--strip[=N]`` option
1182 the first ``N`` subdirectories (all if no ``N`` is given) get
1183 stripped off. Names are always ``--strip``'d before being
1184 ``--flatten``'d. With the option ``--numbered`` (which implies
1185 ``--flatten``) the patch names get a number as prefix to allow
1186 getting the order without consulting the series file, which
1187 eases sending out the patches.
1189 | TODO: Make stripping of non-essential headers configurable
1190 | TODO: Make stripping of [PATCH] and other prefixes configurable
1191 | TODO: ``--mbox`` option to export instead as an mbox file
1192 | TODO: support ``--all`` option in other modes of operation
1193 | TODO: For quilt exporting, export the linearized history created in
1194 a temporary branch--this would allow producing conflict-less
1199 Import commits within the given revision range into TopGit,
1200 creating one topic branch per commit. The dependencies are set
1201 up to form a linear sequence starting on your current branch --
1202 or a branch specified by the ``-d`` parameter, if present.
1204 The branch names are auto-guessed from the commit messages and
1205 prefixed by ``t/`` by default; use ``-p <prefix>`` to specify an
1206 alternative prefix (even an empty one).
1208 Alternatively, you can use the ``-s NAME`` parameter to specify
1209 the name of the target branch; the command will then take one
1210 more argument describing a *single* commit to import.
1214 Update the current, specified or all topic branches with respect
1215 to changes in the branches they depend on and remote branches.
1216 This is performed in two phases -- first, changes within the
1217 dependencies are merged to the base, then the base is merged
1218 into the topic branch. The output will guide you on what to do
1219 next in case of conflicts.
1221 You have enabled ``git rerere`` haven't you?
1223 When ``-a`` (or ``--all``) is specifed, updates all topic branches
1224 matched by ``<pattern>``'s (see ``git-for-each-ref(1)`` for details),
1225 or all if no ``<pattern>`` is given. Any topic branches with missing
1226 dependencies will be skipped entirely unless ``--skip-missing`` is
1229 When ``--skip-missing`` is specifed, an attempt is made to update topic
1230 branches with missing dependencies by skipping only the dependencies
1231 that are missing. Caveat utilitor.
1233 When ``--stash`` is specified (or the ``topgit.autostash`` config
1234 value is set to ``true``), a ref stash will be automatically created
1235 just before beginning updates if any are needed. The ``--no-stash``
1236 option may be used to disable a ``topgit.autostash=true`` setting.
1237 See the ``tg tag`` ``--stash`` option for details.
1239 After the update, if a single topic branch was specified, it is
1240 left as the current one; if ``-a`` was specified, it returns to
1241 the branch which was current at the beginning.
1243 If your dependencies are not up-to-date, ``tg update`` will first
1244 recurse into them and update them.
1246 If a remote branch update brings in dependencies on branches
1247 that are not yet instantiated locally, you can either bring in
1248 all the new branches from the remote using ``tg remote
1249 --populate``, or only pick out the missing ones using ``tg create
1250 -r`` (``tg summary`` will point out branches with incomplete
1251 dependencies by showing an ``!`` next to them).
1253 | TODO: ``tg update -a -c`` to autoremove (clean) up-to-date branches
1257 If ``-a`` or ``--all`` was specified, pushes all non-annihilated
1258 TopGit-controlled topic branches, to a remote repository.
1259 Otherwise, pushes the specified topic branches -- or the
1260 current branch, if you don't specify which. By default, the
1261 remote gets all the dependencies (both TopGit-controlled and
1262 non-TopGit-controlled) and bases pushed to it too. If
1263 ``--tgish-only`` was specified, only TopGit-controlled
1264 dependencies will be pushed, and if ``--no-deps`` was specified,
1265 no dependencies at all will be pushed.
1267 The ``--dry-run`` and ``--force`` options are passed directly to
1268 ``git push`` if given.
1270 The remote may be specified with the ``-r`` option. If no remote
1271 was specified, the configured default TopGit remote will be
1276 Prints the base commit of each of the named topic branches, or
1277 the current branch if no branches are named. Prints an error
1278 message and exits with exit code 1 if the named branch is not
1283 Prints the git log of the named topgit branch -- or the current
1284 branch, if you don't specify a name.
1286 This is really just a convenient shortcut for:
1288 ``git log --first-parent --no-merges $(tg base <name>)..<name>``
1290 where ``<name>`` is the name of the TopGit topic branch (or omitted
1291 for the current branch).
1293 NOTE: if you have merged changes from a different repository, this
1294 command might not list all interesting commits.
1298 Creates a TopGit annotated/signed tag or lists the reflog of one.
1300 A TopGit annotated tag records the current state of one or more TopGit
1301 branches and their dependencies and may be used to revert to the tagged
1302 state at any point in the future.
1304 When reflogs are enabled (the default in a non-bare repository) and
1305 combined with the ``--force`` option a single tag name may be used as a
1306 sort of TopGit branch state stash. The special branch name ``--all``
1307 may be used to tag the state of all current TopGit branches to
1308 facilitate this function and has the side-effect of suppressing the
1309 out-of-date check allowing out-of-date branches to be included.
1311 As a special feature, ``--stash`` may be used as the tag name in which
1312 case ``--all`` is implied if no branch name is listed (instead of the
1313 normal default of ``HEAD``), ``--force`` and ``--no-edit`` (use
1314 ``--edit`` to change that) are automatically activated and the tag will
1315 be saved to ``refs/tgstash`` instead of ``refs/tags/<tagname>``.
1316 The ``--stash`` tag name may also be used with the ``-g``/``--reflog``
1319 The mostly undocumented option ``--allow-outdated`` will bypass the
1320 out-of-date check and is implied when ``--stash`` or ``--all`` is used.
1322 A TopGit annotated/signed tag is simply a Git annotated/signed tag with
1323 a "TOPGIT REFS" section appended to the end of the tag message (and
1324 preceding the signature for signed tags). PEM-style begin and end
1325 lines surround one line per ref where the format of each line is
1326 full-hash SP ref-name. A line will be included for each branch given
1327 on the command line and each ref they depend on either directly or
1330 If more than one TopGit branch is given on the command line, a new
1331 commit will be created that has an empty tree and all of the given
1332 TopGit branches as parents and that commit will be tagged. If a single
1333 TopGit branch is given, then it will be tagged. If the ``--tree``
1334 option is used then it will be used instead of an empty tree (a new
1335 commit will be created if necessary to guarantee the specified tree is
1336 what's in the commit the newly created tag refers to). The argument to
1337 the ``--tree`` option may be any valid treeish.
1339 All the options for creating a tag serve the same purpose as their Git
1340 equivalents except for two. The ``--refs`` option suppresses tag
1341 creation entirely and emits the "TOPGIT REFS" section that would have
1342 been included with the tag. If the ``--no-edit`` option is given and
1343 no message is supplied (via the ``-m`` or ``-F`` option) then the
1344 default message created by TopGit will be used without running the
1347 With ``-g`` or ``--reflog`` show the reflog for a tag. With the
1348 ``--reflog-message`` option the message from the reflog is shown.
1349 With the ``--commit-message`` option the first line of the tag's
1350 message (if the object is a tag) or the commit message (if the object
1351 is a commit) falling back to the reflog message for tree and blob
1352 objects is shown. The default is ``--reflog-message`` unless the
1353 ``--stash`` (``refs/tgstash``) is being shown in which case the default
1354 is then ``--commit-message``. Just add either option explicitly to
1355 override the default.
1357 When showing reflogs, non-tag entries are annotated with their type
1358 unless ``--no-type`` is given.
1360 TopGit tags are created with a reflog if core.logallrefupdates is
1361 enabled (the default for non-bare repositories). Unfortunately Git
1362 is incapable of showing an annotated/signed tag's reflog
1363 (using git log -g) as it will first resolve the tag before checking to
1364 see if it has a reflog. Git can, however, show reflogs for lightweight
1365 tags (using git log -g) just fine but that's not helpful here. Use
1366 ``tg tag`` with the ``-g`` or ``--reflog`` option to see the reflog for
1367 an actual tag object. This also works on non-TopGit annotated/signed
1368 tags as well provided they have a reflog.
1370 The number of entries shown may be limited with the ``-n`` option. If
1371 the tagname is omitted then ``--stash`` is assumed.
1373 The ``--delete`` option is a convenience option that runs the
1374 ``git update-ref -d`` command on the specified tag removing it and its
1375 reflog (if it has one).
1377 The ``--clear`` option clears all but the most recent (the ``@{0}``)
1378 reflog entries from the reflog for the specified tag. It's equivalent
1379 to dropping all the higher numbered reflog entries.
1381 The ``--drop`` option drops the specified reflog entry and requires the
1382 given tagname to have an ``@{n}`` suffix where ``n`` is the reflog
1383 entry number to be dropped. This is really just a convenience option
1384 that runs the appropriate ``git reflog delete`` command.
1386 Note that when combined with ``tg revert``, a tag created by ``tg tag``
1387 can be used to transfer TopGit branches. Simply create the tag, push
1388 it somewhere and then have the recipient run ``tg revert`` to recreate
1389 the TopGit branches. This may be helpful in situations where it's not
1390 feasible to push all the refs corresponding to the TopGit-controlled
1391 branches and their top-bases.
1395 Provides a ``git rebase`` rerere auto continue function. It may be
1396 used as a drop-in replacement front-end for ``git rebase -m`` that
1397 automatically continues the rebase when ``git rerere`` information is
1398 sufficient to resolve all conflicts.
1400 You have enabled ``git rerere`` haven't you?
1402 If the ``-m`` or ``--merge`` option is not present then ``tg rebase``
1403 will complain and not do anything.
1405 When ``git rerere`` is enabled, previously resolved conflicts are
1406 remembered and can be automatically staged (see ``rerere.autoUpdate``).
1408 However, even with auto staging, ``git rebase`` still stops and
1409 requires an explicit ``git rebase --continue`` to keep going.
1411 In the case where ``git rebase -m`` is being used to flatten history
1412 (such as after a ``tg export --collapse`` prior to a
1413 ``git format-patch``), there's a good chance all conflicts have already
1414 been resolved during normal merge maintenance operations so there's no
1415 reason ``git rebase`` could not automatically continue, but there's no
1416 option to make it do so.
1418 The ``tg rebase`` command provides a ``git rebase --auto-continue``
1421 All the same rebase options can be used (they are simply passed through
1422 to Git unchanged). However, the ``rerere.autoUpdate`` option is
1423 automatically temporarily enabled while running ``git rebase`` and
1424 should ``git rebase`` stop asking one to resolve and continue, but all
1425 conflicts have already been resolved and staged using rerere
1426 information, then ``git rebase --continue`` will be automatically run.
1430 Provides the ability to revert one or more TopGit branches and their
1431 dependencies to a previous state contained within a tag created using
1432 the ``tg tag`` command. In addition to the actual revert mode
1433 operation a list mode operation is also provided to examine a tag's ref
1436 The default mode (``-l`` or ``--list``) shows the state of one or more
1437 of the refs/branches stored in the tag data. When no refs are given on
1438 the command line, all refs in the tag data are shown. With the special
1439 ref name ``--heads`` then the indepedent heads contained in the tag
1440 data are shown. The ``--deps`` option shows the specified refs and all
1441 of their dependencies in a single list with no duplicates. The
1442 ``--rdeps`` option shows a display similar to ``tg summary --rdeps``
1443 for each ref or all TopGit heads if no ref is given on the command
1444 line. The standard ``--no-short``, ``--short=n`` etc. options may be
1445 used to override the default ``--short`` output. With ``--hash`` (or
1446 ``--hash-only``) show only the hash in ``--list`` mode in which case
1447 the default is ``--no-short``. The ``--hash`` option can be used much
1448 like the ``git rev-parse --verify`` command to extract a specific hash
1449 value out of a TopGit tag.
1451 Note that unlike `tg summary`_, here ``--heads`` actually does mean the
1452 ``git merge-base --independent`` heads of the stored refs from the tag
1453 data. To see only the independent TopGit topic branch heads stored in
1454 the tag data use the ``--topgit-heads`` option instead. The default
1455 for the ``--rdeps`` option is ``--topgit-heads`` but ``--heads`` can
1456 be given explicitly to change that. (Note that ``--heads-independent``
1457 is accepted as an alias for ``--heads`` as well.)
1459 The revert mode has three submodes, dry-run mode (``-n`` or
1460 ``--dry-run``), force mode (``-f`` or ``--force``) and interactive mode
1461 (``-i`` or ``--interactive``). If ``--dry-run`` (or ``-n``) is given
1462 no ref updates will actually be performed but what would have been
1463 updated is shown instead. If ``--interactive`` (or ``-i``) is given
1464 then the editor is invoked on an instruction sheet allowing manual
1465 selection of the refs to be updated before proceeding. Since revert is
1466 potentially a destructive operation, at least one of the submodes must
1467 be specified explicitly. If no refs are listed on the command line
1468 then all refs in the tag data are reverted. Otherwise the listed refs
1469 and all of their dependencies (unless ``--no-deps`` is given) are
1470 reverted. Unless ``--no-stash`` is given a new stash will be created
1471 using ``tg tag --stash`` (except, of course, in dry-run mode) just
1472 before actually performing the updates to facilitate recovery from
1475 Both modes accept fully-qualified (i.e. starts with ``refs/``) ref
1476 names as well as unqualified names (which will be assumed to be located
1477 under ``refs/heads/``). In revert mode a tgish ref will always have
1478 both its ``refs/heads/`` and ``refs/top-bases/`` values included no
1479 matter how it's listed unless ``--no-deps`` is given and the ref is
1480 fully qualified (i.e. starts with ``refs/``) or one or the other of its
1481 values was removed from the instruction sheet in interactive mode. In
1482 list mode a tgish ref will always have both its ``refs/heads/`` and
1483 ``refs/top-bases/`` values included only when using the ``--deps`` or
1484 ``--rdeps`` options.
1486 The ``--tgish-only`` option excludes non-tgish refs (i.e. refs that do
1487 not have a ``refs/heads/<name>``, ``refs/top-bases/<name>`` pair).
1489 The ``--exclude`` option (which can be repeated) excludes specific
1490 refs. If the name given to ``--exclude`` is not fully-qualified (i.e.
1491 starts with ``refs/``) then it will exclude both members of a tgish ref
1494 The ``--quiet`` (or ``-q``) option may be used in revert mode to
1495 suppress non-dry-run ref change status messages.
1497 The special tag name ``--stash`` (as well as with ``@{n}`` suffixes)
1498 can be used to refer to ``refs/tgstash``.
1500 The ``tg revert`` command supports tags of tags that contains TopGit
1501 refs. So, for example, if you do this::
1504 git tag -f -a -m "tag the tag" newtag newtag
1506 Then ``newtag`` will be a tag of a tag containing a ``TOPGIT REFS``
1507 section. ``tg revert`` knows how to dereference the outermost
1508 tag to get to the next (and the next etc.) tag to find the
1509 ``TOPGIT REFS`` section so after the above sequence, the tag ``newtag``
1510 can still be used successfully with ``tg revert``.
1512 NOTE: If HEAD points to a ref that is updated by a revert operation
1513 then NO WARNING whatsoever will be issued, but the index and working
1514 tree will always be left completely untouched (and the reflog for
1515 the pointed-to ref can always be used to find the previous value).
1519 Outputs the direct dependencies for the current or named branch.
1522 -i show dependencies based on index instead of branch
1523 -w show dependencies based on working tree instead of branch
1527 Outputs all branches which directly depend on the current or
1531 -i show dependencies based on index instead of branch
1532 -w show dependencies based on working tree instead of branch
1536 Transition top-bases from old location to new location.
1538 Beginning with TopGit release 0.19.4, TopGit has the ability to store
1539 the top-bases refs in either the old ``ref/top-bases/...`` location or
1540 the new ``refs/heads/{top-bases}/...`` location. Starting with TopGit
1541 release 0.20.0, the default is the new location.
1543 By storing the top-bases under heads, Git is less likely to complain
1544 when manipulating them, hosting providers are more likely to provide
1545 access to them and Git prevents them from pointing at anything other
1546 than a commit object. All in all a win for everyone.
1548 TopGit attempts to automatically detect whether the new or old location
1549 is being used for the top-bases and just do the right thing. However,
1550 by explicitly setting the config value ``topgit.top-bases`` to either
1551 ``refs`` for the old location or ``heads`` for the new location the
1552 auto-detection can be bypassed. If no top-bases refs are present in
1553 the repository the default prior to TopGit release 0.20.0 is to use the
1554 old location but starting with TopGit release 0.20.0 the default is to
1555 use the new location.
1557 The ``tg migrate-bases`` command may be used to migrate top-bases refs
1558 from the old location to the new location (or, by using the
1559 undocumented ``--reverse`` option, vice versa).
1561 With few exceptions (``tg create -r`` and ``tg revert``), all top-bases
1562 refs (both local *and* remote refs) are expected to be stored in the
1563 same location (either new or old). A repository's current location for
1564 storing top-bases refs may be shown with the ``tg --top-bases`` command.
1572 TopGit stores all the topic branches in the regular ``refs/heads/``
1573 namespace (so we recommend distinguishing them with the ``t/`` prefix).
1574 Apart from that, TopGit also maintains a set of auxiliary refs in
1575 ``refs/top-*``. Currently, only ``refs/top-bases/`` is used, containing the
1576 current *base* of the given topic branch -- this is basically a merge of
1577 all the branches the topic branch depends on; it is updated during ``tg
1578 update`` and then merged to the topic branch, and it is the base of a
1579 patch generated from the topic branch by ``tg patch``.
1581 All the metadata is tracked within the source tree and history of the
1582 topic branch itself, in ``.top*`` files; these files are kept isolated
1583 within the topic branches during TopGit-controlled merges and are of
1584 course omitted during ``tg patch``. The state of these files in base
1585 commits is undefined; look at them only in the topic branches
1586 themselves. Currently, two files are defined:
1589 Contains the description of the topic branch in a
1590 mail-like format, plus the author information, whatever
1591 Cc headers you choose or the post-three-dashes message.
1592 When mailing out your patch, basically only a few extra
1593 mail headers are inserted and then the patch itself is
1594 appended. Thus, as your patches evolve, you can record
1595 nuances like whether the particular patch should have
1596 To-list / Cc-maintainer or vice-versa and similar
1597 nuances, if your project is into that. ``From`` is
1598 prefilled from your current ``GIT_AUTHOR_IDENT``; other
1599 headers can be prefilled from various optional
1600 ``topgit.*`` git config options.
1603 Contains the one-per-line list of branches this branch
1604 depends on, pre-seeded by ``tg create``. A (continuously
1605 updated) merge of these branches will be the *base* of
1608 IMPORTANT: DO NOT EDIT ``.topdeps`` MANUALLY!!! If you do so, you need to
1609 know exactly what you are doing, since this file must stay in sync with
1610 the Git history information, otherwise very bad things will happen.
1612 TopGit also automagically installs a bunch of custom commit-related
1613 hooks that will verify whether you are committing the ``.top*`` files in a
1614 sane state. It will add the hooks to separate files within the ``hooks/``
1615 subdirectory, and merely insert calls to them to the appropriate hooks
1616 and make them executable (but will make sure the original hook's code is
1617 not called if the hook was not executable beforehand).
1619 Another automagically installed piece is a ``.git/info/attributes``
1620 specifier for an ``ours`` merge strategy for the files ``.topmsg`` and
1621 ``.topdeps``, and the (intuitive) ``ours`` merge strategy definition in
1628 There are two remaining issues with accessing topic branches in remote
1631 (i) Referring to remote topic branches from your local repository
1632 (ii) Developing some of the remote topic branches locally
1634 There are two somewhat contradictory design considerations here:
1636 (a) Hacking on multiple independent TopGit remotes in a single
1638 (b) Having a self-contained topic system in local refs space
1640 To us, (a) does not appear to be very convincing, while (b) is quite
1641 desirable for ``git-log topic`` etc. working, and increased conceptual
1644 Thus, we choose to instantiate all the topic branches of given remote
1645 locally; this is performed by ``tg remote --populate``. ``tg update``
1646 will also check if a branch can be updated from its corresponding remote
1647 branch. The logic needs to be somewhat involved if we are to "do the
1648 right thing". First, we update the base, handling the remote branch as
1649 if it was the first dependency; thus, conflict resolutions made in the
1650 remote branch will be carried over to our local base automagically.
1651 Then, the base is merged into the remote branch and the result is merged
1652 to the local branch -- again, to carry over remote conflict resolutions.
1653 In the future, this order might be adjustable on a per-update basis, in
1654 case local changes happen to be diverging more than the remote ones.
1655 (See the details in `The Update Process`_ for more in depth coverage.)
1657 All commands by default refer to the remote that ``tg remote --populate``
1658 was called on the last time (stored in the ``topgit.remote`` git
1659 configuration variable). You can manually run any command with a
1660 different base remote by passing ``-r REMOTE`` *before* the subcommand
1667 A familiarity with the terms in the GLOSSARY_ is helpful for understanding the
1668 content of this sections. See also the IMPLEMENTATION_ section.
1673 When a branch is "updated" using the ``tg update`` command the following steps
1676 1) The branch and all of its dependencies (and theirs recursively)
1677 are checked to see which ones are *out-of-date*. See glossary_.
1679 2) Each of the branch's direct dependencies (i.e. they are listed in
1680 the branch's ``.topdeps`` file) which is out of date is updated
1681 before proceeding (yup, this is a recursive process).
1683 3) Each of the branch's direct dependencies (i.e. they are listed in
1684 the branch's ``.topdes`` file) that was updated in the previous
1685 step is now merged into the branch's corresponding base. If a
1686 remote is involved, and the branch's corresponding base does NOT
1687 contain the remote branch's corresponding base that remote base is
1688 also merged into the branch's base at this time as well (it will be
1689 the first item merged into the branch's base).
1691 4) If the branch has a corresponding remote branch and the branch
1692 does not already contain it, it's merged into the branch's base
1693 (which was possibly already updated in step (3) to contain the
1694 remote branch's base but not the remote branch itself) on a detached
1695 HEAD. Yup, this step can be a bit confusing and no, the updated
1696 base from step (3) has not yet been merged into the branch itself
1697 yet either. If there is no remote branch this step does not apply.
1698 Using a detached HEAD allows the remote branch to be merged into the
1699 contents of the base without actually perturbing the base's ref.
1701 5) If there is a remote branch present then use the result of step (4)
1702 otherwise use the branch's base and merge that into the branch
1705 That's it! Simple, right? ;)
1707 Unless the auto stash option has been disabled (see `no undo`_, `tg update`_
1708 and `tg tag`_), a copy of all the old refs values will be stashed away
1709 immediately after step (1) before starting step (2), but only if anything is
1710 actually found to be out-of-date.
1715 The ``tg update`` command regularly performs merges while executing an update
1716 operation. In order to speed things up, it attempts to do in-index merges
1717 where possible. It accomplishes this by using a separate, temporary index
1718 file and the ``git read-tree -m --aggressive`` command possibly assisted by
1719 the ``git merge-index`` and ``git merge-file`` commands. This combination may
1720 be repeated more than once to perform an octopus in-index merge. If this
1721 fails, the files are checked out and a normal ``git merge`` three-way merge is
1722 performed (possily multiple times). If the normal ``git merge`` fails then
1723 user intervention is required to resolve the merge conflict(s) and continue.
1725 Since the ``tg annihilate``, ``tg create`` and ``tg depend add`` commands may
1726 end up running the ``tg update`` machinery behind the scenes to complete their
1727 operation they may also result in any of these merge strategies being used.
1729 In addition to the normal Git merge strategies (if the in-index merging fails),
1730 there are four possible TopGit merge strategies that may be shown. Since they
1731 all involve use of the ``git read-tree -m --aggressive`` command they are all
1732 variations of a "trivial aggressive" merge. The "trivial" part because all of
1733 the merges done by ``git read-tree -m`` are described as "trivial" and the
1734 "aggressive" part because the ``--aggressive`` option is always used.
1736 1) "trivial aggressive"
1737 Only two heads were involved and all merging was completed by
1738 the ``git read-tree -m --aggressive`` command.
1740 2) "trivial aggressive automatic"
1741 Only two heads were involved but after the
1742 ``git read-tree -m --aggressive`` command completed there were
1743 still unresolved items and ``git merge-index`` had to be run
1744 (using the ``tg index-merge-one-file`` driver) which ultimately
1745 ran ``git merge-file`` at least once to perform a simple
1746 automatic three-way merge. Hence the "automatic" description
1747 and the "Auto-merging ..." output line(s).
1749 3) "trivial aggressive octopus"
1750 This is the same as a "trivial aggressive" merge except that
1751 more than two heads were involved and after merging the first
1752 two heads, the ``git read-tree -m --aggressive`` step was
1753 repeated again on the result for each additional head. All
1754 merging was completed via multiple
1755 ``git read-tree -m --aggressive`` commands only.
1756 This beast is relatively rare in the wild.
1758 4) "trivial aggressive automatic octopus"
1759 This is very similar to the "trivial aggressive octopus"
1760 except that at least one of the ``git read-tree -m --aggressive``
1761 commands left unresolved items that were handled the same way
1762 as the "trivial aggressive automatic" strategy. This species
1763 is commonly seen in the wild.
1770 Version-controlled file stored at the root level of each
1771 TopGit branch that contains the patch header for a TopGit
1772 branch. See also IMPLEMENTATION_;
1775 Version-controlled file stored at the root level of each
1776 TopGit branch that lists the branch's dependencies one per
1777 line omitting the leading ``refs/heads/`` part. See also
1781 Given two Git commit identifiers (e.g. hashes) C1 and C2,
1782 commit C1 "contains" commit C2 if either they are the same
1783 commit or C2 can be reached from C1 by following one or more
1784 parent links from C1 (perhaps via one or more intermediate
1785 commits along the way). In other words, if C1 contains C2
1786 then C2 is an ancestor of C1 or conversely C1 is a descendant
1787 of C2. Since a TopGit branch name is also the name of a Git
1788 branch (something located under the ``refs/heads`` Git
1789 namespace) and similarly for a TopGit base, they can both be
1790 resolved to a Git commit identifier and then participate in
1791 a branch containment test. An easy mnemonic for this is
1792 "children contain the genes of their parents."
1795 See branch containment.
1798 Excellent system for managing a history of changes to one
1799 or more possibly interrelated patches.
1802 A Git branch that has an associated TopGit base. Conceptually
1803 it represents a single patch that is the difference between
1804 the associated TopGit base and the TopGit branch. In other
1805 words ``git diff-tree <TopGit base> <TopGit branch>`` except
1806 that any ``.topdeps`` and/or ``.topmsg`` files are excluded
1807 from the result and the contents of the ``.topmsg`` file from
1808 the TopGit branch is prefixed to the result.
1811 A Git branch that records the base upon which a TopGit branch's
1812 single conceptual "patch" is built. The name of the Git branch
1813 is derived from the TopGit branch name by stripping off the
1814 leading ``refs/heads/`` and appending the correct prefix where
1815 all TopGit bases are stored (typically either
1816 ``refs/top-bases/`` or ``refs/heads/{top-bases}/`` -- the
1817 prefix for any given repository can be shown by using the
1818 ``tg --top-bases`` command and updated using the
1819 ``tg migrate-bases`` command).
1821 All of a TopGit branch's dependencies are merged into the
1822 corresponding TopGit base during a ``tg update`` of a branch.
1827 TopGit ``[PATCH]`` branch
1828 A TopGit branch whose subject starts with ``[PATCH]``. By
1829 convention these TopGit branches contain a single patch
1830 (equivalent to a single patch file) and have at least one
1831 dependency (i.e. their ``.topdeps`` files are never empty).
1833 TopGit ``[BASE]`` branch
1834 A TopGit branch whose subject starts with ``[BASE]``. By
1835 convention these TopGit branches do not actually contain
1836 any changes and their ``.topdeps`` files are empty. They
1837 are used to control a base dependency that another set of
1838 branches depends on.
1840 TopGit ``[STAGE]`` branch
1841 A TopGit branch whose subject starts with ``[STAGE]``. By
1842 convention these TopGit branches do not actually contain any
1843 changes of their own but do have one or (typically) more
1844 dependencies in their ``.topdeps`` file. These branches are
1845 used to bring together one or (typically) more independent
1846 TopGit ``[PATCH]`` branches into a single branch so that
1847 testing and/or evaluation can be performed on the result.
1850 When merging two (or more) heads that touch the same lines in
1851 the file but in different ways the result is a merge conflict
1852 that requires manual intervention. If a merge conflict occurs
1853 with more than two heads (an octopus merge) it's generally
1854 replaced by multiple three-way merges so that by the time a
1855 user sees a merge conflict needing manual resolution, there
1856 will be only two heads involved.
1859 A Git merge strategy (see the "MERGE STRATEGIES" section of
1860 ``git help merge``) or one of the TopGit `merge strategies`_
1861 used to merge two or more heads.
1863 TopGit merge strategy
1864 See the `Merge Strategies`_ section above for details but
1865 basically these are just in-index merges done using the
1866 ``git read-tree -m --aggressive`` command one or more times
1867 possibily assisted by the ``git merge-index`` and the
1868 ``git merge-file`` commands.
1871 A merge involving more than two heads. Note that if there are
1872 less than three independent heads the resulting merge that
1873 started out as an octopus will end up not actually being an
1877 A TopGit branch is considered to be "out-of-date" when ANY of
1878 the following are true:
1880 a) The TopGit branch does NOT contain its
1883 b) The TopGit branch does NOT contain its
1884 corresponding remote branch (there may not be
1885 a remote branch in which case this does not apply)
1887 c) The TopGit branch's base does NOT contain its
1888 corresponding remote branch's base (there may not be
1889 a remote branch in which case this does not apply)
1891 d) Any of the TopGit branches listed in the branch's
1892 ``.topdeps`` file are NOT contained by the branch.
1893 (See "branch containment" above.)
1895 e) Any of the TopGit branches listed in the branch's
1896 ``.topdeps`` file are out-of-date.
1898 Note that if a remote branch is present and is NOT out-of-date
1899 then it will contain its own base and (c) is mostly redundant.
1901 remote TopGit branch
1902 A Git branch with the same branch name as a TopGit branch
1903 but living under ``refs/remotes/<some remote>/`` instead
1904 of just ``refs/heads/``.
1907 The TopGit base branch corresponding to a remote TopGit branch,
1908 which lives under ``refs/remotes/`` somewhere (depending on
1909 what the output of ``tg --top-bases`` is for that remote).
1912 A three-way merge takes a common base and two heads (call them
1913 A and B) and creates a new file that is the common base plus
1914 all of the changes made between the common base and head A
1915 *AND* all of the changes made between the common base and
1916 head B. The technique used to accomplish this is called a
1923 The following references are useful to understand the development of
1924 topgit and its subcommands.
1927 http://public-inbox.org/git/36ca99e90904091034m4d4d31dct78acb333612e678@mail.gmail.com/T/#u
1930 THIRD-PARTY SOFTWARE
1931 --------------------
1933 The following software understands TopGit branches:
1935 * `magit <http://magit.github.io/>`_ -- a git mode for emacs
1937 IMPORTANT: Magit requires its topgit mode to be enabled first, as
1938 described in its documentation, in the "Activating extensions"
1939 subsection. If this is not done, it will not push TopGit branches
1940 correctly, so it's important to enable it even if you plan to mostly use
1941 TopGit from the command line.