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 :SYNOPSIS_: Command line example session
20 :USAGE_: Command line details
21 :`NO UNDO`_: Where's the undo!!!
22 :CONVENTIONS_: Suggestions for organizing your TopGit branches
23 :`EXTRA SETTINGS`_: Various possible "topgit.*" config settings
24 :ALIASES_: Git-like TopGit command aliases
25 :NAVIGATION_: Getting around with "next" and "prev"
26 :GLOSSARY_: All the TopGit vocabulary in one place
27 :TECHNICAL_: How it works behind the scenes
28 :`TESTING TOPGIT`_: How to run the TopGit test suite
34 TopGit is a collection of POSIX shell scripts so a POSIX-compliant shell is
35 required along with some standard POSIX-compliant utilities (e.g. sed, awk,
36 cat, etc.). Git version 1.8.5 or later is also required.
38 To use TopGit with linked working trees (the ``git worktree add`` command),
39 at least Git version 2.5.0 (obviously, since that's when the ``git worktree``
40 command first appeared) is needed in which case linked working trees are then
41 fully supported for use with TopGit.
43 The scripts need to be preprocessed and installed. The Makefile that does
44 this requires a POSIX make utility (using "``make``" and "``make install``")
45 and some version of ``perl`` in the ``PATH`` somewhere (the ``perl`` binary
46 is needed for correct help text file generation prior to the actual install).
48 Once installed, TopGit uses only POSIX-compliant utilities (except that it
49 also requires, obviously, Git).
51 Running the tests (see `TESTING TOPGIT`_) has the same requirements as for
52 installation (i.e. POSIX plus Perl).
54 It is possible to use the DESTDIR functionality to install TopGit to a
55 staging area on one machine, archive that and then unarchive it on another
56 machine to perform an install (provided the build prefix and other options are
57 compatible with the final installed location).
63 See the file ``INSTALL``.
69 The TopGit git repository can be found at <http://repo.or.cz/topgit/pro>.
75 Why not use something like StGIT or Guilt or ``rebase -i`` for maintaining
76 your patch queue? The advantage of these tools is their simplicity;
77 they work with patch *series* and defer to the reflog facility for
78 version control of patches (reordering of patches is not
79 version-controlled at all). But there are several disadvantages -- for
80 one, these tools (especially StGIT) do not actually fit well with plain
81 Git at all: it is basically impossible to take advantage of the index
82 effectively when using StGIT. But more importantly, these tools
83 horribly fail in the face of a distributed environment.
85 TopGit has been designed around three main tenets:
87 (i) TopGit is as thin a layer on top of Git as possible. You
88 still maintain your index and commit using Git; TopGit will only
89 automate a few indispensable tasks.
91 (ii) TopGit is anxious about *keeping* your history. It will
92 never rewrite your history, and all metadata is also tracked
93 by Git, smoothly and non-obnoxiously. It is good to have a
94 *single* point when the history is cleaned up, and that is at
95 the point of inclusion in the upstream project; locally, you
96 can see how your patch has evolved and easily return to older
99 (iii) TopGit is specifically designed to work in a
100 distributed environment. You can have several instances of
101 TopGit-aware repositories and smoothly keep them all
102 up-to-date and transfer your changes between them.
104 As mentioned above, the main intended use-case for TopGit is tracking
105 third-party patches, where each patch is effectively a single topic
106 branch. In order to flexibly accommodate even complex scenarios when
107 you track many patches where many are independent but some depend on
108 others, TopGit ignores the ancient Quilt heritage of patch series and
109 instead allows the patches to freely form graphs (DAGs just like Git
110 history itself, only "one level higher"). For now, you have to manually
111 specify which patches the current one depends on, but TopGit might help
112 you with that in the future in a darcs-like fashion.
114 A glossary_ plug: The union (i.e. merge) of patch dependencies is called
115 a *base* of the patch (topic branch).
117 Of course, TopGit is perhaps not the right tool for you:
119 (i) TopGit is not complicated, but StGIT et al. are somewhat
120 simpler, conceptually. If you just want to make a linear
121 purely-local patch queue, deferring to StGIT instead might
124 (ii) When using TopGit, your history can get a little hairy
125 over time, especially with all the merges rippling through.
134 ## Create and evolve a topic branch
135 $ tg create t/gitweb/pathinfo-action
136 tg: Automatically marking dependency on master
137 tg: Creating t/gitweb/pathinfo-action base from master...
143 ## Create another topic branch on top of the former one
144 $ tg create t/gitweb/nifty-links
145 tg: Automatically marking dependency on t/gitweb/pathinfo-action
146 tg: Creating t/gitweb/nifty-links base from t/gitweb/pathinfo-action...
150 ## Create another topic branch on top of master and submit
151 ## the resulting patch upstream
152 $ tg create t/revlist/author-fixed master
153 tg: Creating t/revlist/author-fixed base from master...
157 tg: Sent t/revlist/author-fixed
159 To: git@vger.kernel.org
160 Cc: gitster@pobox.com
161 Subject: [PATCH] Fix broken revlist --author when --fixed-string
163 ## Create another topic branch depending on two others non-trivially
164 $ tg create t/whatever t/revlist/author-fixed t/gitweb/nifty-links
165 tg: Creating t/whatever base from t/revlist/author-fixed...
166 tg: Merging t/whatever base with t/gitweb/nifty-links...
168 tg: Please commit merge resolution and call: tg update --continue
169 tg: It is also safe to abort this operation using `git reset --hard`
170 tg: but please remember you are on the base branch now;
171 tg: you will want to switch to a different branch.
174 $ tg update --continue
178 ## Update a single topic branch and propagate the changes to
180 $ git checkout t/gitweb/nifty-links
183 $ git checkout t/whatever
185 Topic Branch: t/whatever (1 commit)
186 Subject: [PATCH] Whatever patch
188 Depends: t/revlist/author-fixed t/gitweb/nifty-links
190 t/gitweb/nifty-links (1 commit)
192 tg: Updating base with t/gitweb/nifty-links changes...
194 tg: Please commit merge resolution and call `tg update --continue`
195 tg: (use `tg status` to see more options)
198 $ tg update --continue
199 tg: Updating t/whatever against new base...
201 tg: Please commit merge resolution and call `tg update --continue`
202 tg: (use `tg status` to see more options)
205 $ tg update --continue
207 ## Update a single topic branch and propagate the changes
208 ## further through the dependency chain
209 $ git checkout t/gitweb/pathinfo-action
212 $ git checkout t/whatever
214 Topic Branch: t/whatever (1/2 commits)
215 Subject: [PATCH] Whatever patch
217 Depends: t/revlist/author-fixed t/gitweb/nifty-links
219 t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
221 tg: Recursing to t/gitweb/nifty-links...
222 [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
224 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
225 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
228 $ tg update --continue
229 [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base...
231 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
232 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
235 $ tg update --continue
236 tg: Updating base with t/gitweb/nifty-links changes...
237 tg: Updating t/whatever against new base...
239 ## Clone a TopGit-controlled repository
242 $ tg remote --populate origin
247 ## Add a TopGit remote to a repository and push to it
248 $ git remote add foo URL
252 ## Update from a non-default TopGit remote
261 When using TopGit there are several common conventions used when working with
262 TopGit branches. None of them are enforced, they are only suggestions.
264 There are three typical uses for a TopGit branch:
267 Normal TopGit branches that represent a single patch. These are known
268 as "patch" TopGit branches.
270 Empty TopGit branches with no dependencies (an empty ``.topdeps`` file)
271 that represent a base upon which other "normal" TopGit branches depend.
272 These are known as "base" TopGit branches (not to be confused with
273 the refs/top-bases/... refs).
275 Empty TopGit branches that serve as a staging area to bring together
276 several other TopGit branches into one place so they can be used/tested
277 all together. These are known as "stage" TopGit branches.
279 An "empty" TopGit branch is one that does not have any changes of its own --
280 it may still have dependencies though ("stage" branches do, "base" branches do
281 not). The ``tg summary`` output shows empty branches with a ``0`` in the
282 listing. Normal "patch" branches that have not been annihilated, "base" and
283 "stage" branches fall into this category. (Annihilated branches are normally
284 omitted from the ``tg summary`` output but can be shown if given explicitly as
285 an argument to the ``tg summary`` command. However, the message line will be
286 incorrect since an annihilated branch has no ``.topmsg`` file of its own.)
288 A "patch" branch name typically starts with ``t/`` whereas "base" and "stage"
289 branch names often do not.
291 A "base" branch is created by using the ``--base`` option of ``tg create``
292 (aka ``--no-deps``) which will automatically suggest a "[BASE]" message prefix
293 rather than "[PATCH]". A "stage" branch is created like a normal patch branch
294 except that the only changes that will ever be made to it are typically to
295 add/remove dependencies. Its subject prefix must be manually changed to
296 "[STAGE]" to reflect its purpose.
298 Since both "base" and "stage" branches typically only have a use for the
299 "Subject:" line from their ``.topmsg`` file, they are quite easily created
300 using the ``--topmsg`` option of ``tg create``.
302 Use of "stage" and "base" branches is completely optional. However, without
303 use of a "stage" branch it will be difficult to test multiple independent
304 patches together all at once. A "base" branch is merely a convenience that
305 provides more explicit control over when a common base for a set of patches
306 gets updated as well as providing a branch that shows in ``tg summary`` output
307 and participates in ``tg remote --populate`` setup.
309 Occasionally the functionality of a "base" branch is needed but it may not
310 be possible to add any `.topdeps` or `.topmsg` files to the desired branch
311 (perhaps it's externally controlled). `BARE BRANCHES`_ can be used in this
312 case, but while TopGit allows them it deliberately does not provide assistance
315 Another advantage to using a "stage" branch is that if a new "patch" branch
316 is created remotely and that new branch is added to a pre-existing "stage"
317 branch on the remote then when the local version of the "stage" branch is
318 updated (after fetching remote updates of course), that new dependency will
319 be merged into the local "stage" branch and the local version of the new remote
320 "patch" branch will be automatically set up at "tg update" time.
322 When using the ``tg tag`` command to create tags that record the current state
323 of one or more TopGit branches, the tags are often created with a name that
326 One last thing, you have enabled ``git rerere`` haven't you?
332 Beware, there is no "undo" after running a ``tg update``!
334 Well, that's not entirely correct. Since ``tg update`` never discards commits
335 an "undo" operation is technically feasible provided the old values of all the
336 refs that were affected by the ``tg update`` operation can be determined and
337 then they are simply changed back to their previous values.
339 In practice though, it can be extremely tedious and error prone looking through
340 log information to try and determine what the correct previous values were.
341 Although, since TopGit tries to make sure reflogs are enabled for top-bases
342 refs, using Git's ``@{date}`` notation on all the refs dumped out by a
343 ``tg tag --refs foo``, where "foo" is the branch that was updated whose update
344 needs to be undone, may work.
346 Alternatively, ``tg tag --stash`` can be used prior to the update and then
347 ``tg revert`` used after the update to restore the previous state. This
348 assumes, of course, that you remember to run ``tg tag --stash`` first.
350 The ``tg update`` command understands a ``--stash`` option that tells it to
351 automatically run ``tg tag --stash`` before it starts making changes (if
352 everything is up-to-date it won't run the stash command at all).
354 The ``--stash`` option is the default nowadays when running ``tg update``,
355 add the ``--no-stash`` option to turn it off.
357 There is a preference for this. Setting the config value ``topgit.autostash``
358 to ``false`` will implicitly add the ``--no-stash`` option to any ``tg update``
359 command unless an explicit ``--stash`` option is given.
361 If you are likely to ever want to undo a ``tg update``, setting
362 ``topgit.autostash`` to ``false`` is highly discouraged!
364 Note that the tags saved by ``tg tag --stash`` are stored in the
365 ``refs/tgstash`` ref and its reflog. Unfortunately, while Git is happy to
366 maintain the reflog (once it's been enabled which ``tg tag`` guarantees for
367 ``refs/tgstash``), Git is unable to view an annotated/signed tag's reflog!
368 Instead Git dereferences the tag and shows the wrong thing. Use the
369 ``tg tag -g`` command to view the ``refs/tgstash`` reflog instead.
375 TopGit supports various config settings:
377 :`tg create`_: ``format.signoff`` template Signed-off-by line
378 :ALIASES_: ``topgit.alias.*`` for Git-like command aliases
379 :`tg update`_: ``topgit.autostash`` automatic stash control
380 :`tg create`_: ``topgit.bcc`` default "Bcc:" value for create
381 :`tg create`_: ``topgit.cc`` default "Cc:" value for create
382 :`tg patch`_: ``topgit.from`` "From:" fixups by ``tg patch``
383 :`REMOTE HANDLING`_: ``topgit.remote`` TopGit's default remote
384 :SEQUESTRATION_: ``topgit.sequester`` for sequestration control
385 :`tg update`_: ``topgit.setAutoUpdate`` => ``rerere.autoUpdate``
386 :`tg create`_: ``topgit.subjectPrefix`` "[$prefix PATCH] foo"
387 :`tg create`_: ``topgit.to`` default "To:" value for create
388 :`tg migrate-bases`_: ``topgit.top-bases`` for refs bases location
394 These work exactly like Git's aliases except they are stored under
395 ``topgit.alias.*`` instead. See the ``git help config`` output under
396 the ``alias.*`` section for details. Do note that while alias nesting is
397 explicitly permitted, a maximum nesting depth of 10 is enforced to help
398 detect accidental aliasing loops and keep them from wedging the machine.
400 For example, to create an ``lc`` alias for the ``tg log --compact`` command
401 this command may be used:
405 git config --global topgit.alias.lc "log --compact"
407 To make it specific to a particular repository just omit the ``--global``
408 option from the command.
413 From Previous to Next
414 ~~~~~~~~~~~~~~~~~~~~~
416 For this section, consider the following patch series, to be applied
417 in numerical order as shown:
421 0001-F_first-patch.diff
422 0002-G_second-builds-on-F.diff
423 0003-H_third-builds-on-G.diff
424 0004-I_fourth-builds-on-H.diff
425 0005-J_fifth-builds-on-I.diff
426 0006-K_sixth-builds-on-J.diff
427 0007-L_last-patch-needs-K.diff
429 If these were applied to some commit in a Git repository, say commit "A"
430 then a history that looks like this would be created:
434 A---F---G---H---I---J---K---L
436 Where the parent of commit "F" is "A" and so on to where the parent of
437 commit "L" is commit "K".
439 If that commit history, from A through L, was then imported into TopGit, one
440 TopGit branch would be created corresponding to each of the commits F
441 through L. This way, for example, if the fourth patch in the series
442 (``0004-I_...diff``) needs work, the TopGit branch corresponding to its patch
443 can be checked out and changes made and then a new version of its patch
444 created (using ``tg patch``) without disturbing the other patches in the series
445 and when ``tg update`` is run, the patches that "follow" the fourth patch
446 (i.e. 5, 6 and 7) will have their corresponding TopGit branches automatically
447 updated to take into account the changes made to the fourth patch.
449 Okay, enough with the review of TopGit systemology
450 ``````````````````````````````````````````````````
452 Imagine then that you are working on the fourth patch (i.e. you have its
453 branch checked out into the working tree) and you want to move to the following
454 patch in the series because you have a nit to pick with it too.
456 If you can't remember the exact name you might have to fumble around or, you
457 can display the name of the following or "next" patch's branch with the, you
458 guessed it, ``tg next`` command. Think of "next" as the "next" logical patch
459 in the series or the next following patch. If the patches are numbered as in
460 the list above, "next" corresponds to the "+1" (plus one) patch.
462 You might have already guessed there's a corresponding ``tg prev`` command
463 which displays the "-1" (minus one) patch. If these commands (``tg next``
464 and ``tg prev``) are not given a branch name to start at they start at the
465 patch corresponding to the current ``HEAD``.
467 Displaying, however, is not so helpful as actually going there. That's where
468 the ``tg checkout`` command comes in. ``tg checkout next`` does a
469 ``git checkout`` of the ``tg next`` branch and, not surprisingly,
470 ``tg checkout prev`` does a ``git checkout`` of the ``tg prev`` branch. For
471 the lazy a single ``n`` or ``p`` can be used with ``tg checkout`` instead of
472 typing out the entire ``next`` or ``prev``. Or, for the anal, ``previous``
473 will also be accepted for ``prev``.
475 Referring to the A...L commit graph shown above, I is the parent of J and,
476 conversely, J is the child of I. (Git only explicitly records the child to
477 parent links, in other words a "child" points to zero or more "parents", but
478 parents are completely clueless about their own children.)
480 For historical reasons, the ``tg checkout`` command accepts ``child`` as a
481 synonym for ``next`` and ``parent`` as a synonym for ``prev``. However, this
482 terminology can be confusing since Git has "parent" links but ``tg checkout``
483 is referring to the TopGit DAG, not Git's. Best to just avoid using ``child``
484 or ``parent`` to talk about navigating the TopGit DAG and reserve them
485 strictly for discussing the Git DAG.
487 There may be more than one
488 ``````````````````````````
490 In a simple linear history as shown above there's always only one "next" or
491 "prev" patch. However, TopGit does not restrict one to only a linear
492 history (although that can make patch exports just a bushel of fun).
494 Suffice it to say that there is always a single linearized ordering for any
495 TopGit patch series since it's always a DAG (Directed Acyclic Graph), but it
496 may not be immediately obvious to the casual observer what that is.
498 The ``tg checkout`` command will display a list to choose from if ``next``
499 or ``prev`` would be ambiguous.
501 Use the ``tg info/checkout --series`` command
502 `````````````````````````````````````````````
504 To see the full, linearized, list of patches with their summary displayed in
505 order from first to last patch in the series, just run the ``tg info --series``
506 command. It takes the name of any patch in the series automatically using
507 ``HEAD`` if none is given. It even provides a nice "YOU ARE HERE" mark in
508 the output list helpful to those who have been absent for a time engaging in
509 otherwise distracting activities and need to be reminded where they are.
511 Using ``tg checkout --series`` can take you there (picking from a list) if
512 you've forgotten the way back to wherever you're supposed to be.
514 Don't get pushy, there's just one more thing
515 ````````````````````````````````````````````
517 For historical reasons, ``tg checkout`` with no arguments whatsoever behaves
518 like ``tg checkout next``. For the same historical reasons, ``tg checkout ..``
519 behaves like ``tg checkout prev`` (think of ``..`` as the "parent" directory
520 and since "parent" means "prev" in this context it will then make sense).
522 Now, for that one more thing. Consider that you have a pristine "upstream"
523 tarball, repository, source dump or otherwise obtained set of unmodified
524 source files that need to be patched. View them like so:
528 +-------------------------------+
529 | Unmodified "upstream" source |
530 | files represented with "A" |
531 +-------------------------------+
533 Now, add the first patch, 0001, to them and view the result like so:
537 +--------------------------+----+
538 | Patch 0001 represented by "F" |
539 +-------------------------------+
540 | Unmodified "upstream" source |
541 | files represented with "A" |
542 +-------------------------------+
544 Not stopping there, "push" patches 2, 3 and 4 onto the stack as well like so:
548 +--------------------------+----+
549 | Patch 0004 represented by "I" |
550 +--------------------------+----+
551 | Patch 0003 represented by "H" |
552 +--------------------------+----+
553 | Patch 0002 represented by "G" |
554 +--------------------------+----+
555 | Patch 0001 represented by "F" |
556 +-------------------------------+
557 | Unmodified "upstream" source |
558 | files represented with "A" |
559 +-------------------------------+
561 In other words, to go to the "next" patch in the series it needs to be "push"ed
562 onto the stack. ``tg checkout`` accepts ``push`` as an alias for ``next``.
564 Similarly to go to the "previous" patch in the series the current one needs
565 to be "pop"ped off the stack. ``tg checkout`` accepts ``pop`` as an alias
568 Unfortunately for these aliases, in Git terminology a "push" has quite a
569 different meaning and the ``tg push`` command does something quite different
570 from ``tg checkout push``. Then there's the matter of using a single letter
571 abbreviation for the lazy -- ``p`` would mean what exactly?
573 ``tg checkout`` continues to accept the ``push`` and ``pop`` aliases for
574 ``next`` and ``prev`` respectively, but it's best to avoid them since
575 ``push`` has an alternate meaning everywhere else in TopGit and Git and that
576 leaves ``pop`` all alone in the dark.
582 No, this is not a section about budget nonsense. ;)
584 TopGit keeps its metadata in ``.topdeps`` and ``.topmsg`` files. In an effort
585 to facilitate cherry-picking and other Git activities on the patch changes
586 themselves while ignoring the TopGit metadata, TopGit attempts to keep all
587 changes to ``.topdeps`` and ``.topmsg`` files limited to commits that do NOT
588 contain changes to any other files.
590 This is a departure from previous TopGit versions that made no such effort.
592 Primarily this affects ``tg create`` and ``tg import`` (which makes use of
593 ``tg create``) as ``tg create`` will commit the initial versions of
594 ``.topdeps`` and ``.topmsg`` for a new TopGit-controlled branch in their own
595 commit instead of mixing them in with changes to other files.
597 The ``pre-commit`` hook will also attempt to separate out any ``.topdeps`` and
598 ``.topmsg`` changes from commits that include changes to other files.
600 It is possible to defeat these checks without much effort (``pre-commit`` hooks
601 can easily be bypassed, ``tg create`` has a ``--no-commit`` option, many Git
602 commands simply do not run the ``pre-commit`` hook, etc.).
604 If you really, really, really, really want to change the default back to the
605 old behavior of previous TopGit versions where no such sequestration took
606 place, then set the ``topgit.sequester`` config variable explicitly to the
607 value ``false``. But this is not recommended.
610 AMENDING AND REBASING AND UPDATE-REF'ING
611 ----------------------------------------
615 It is okay to manually update a top-bases/... ref when a) it has no depedencies
616 (i.e. it was created with the ``tg create`` ``--base`` option) and b) the
617 old top-bases/... ref value can be fast-forwarded to the new top-bases/...
618 value OR the new value contains ALL of the changes in the old value through
619 some other mechanism (perhaps they were cherry-picked or otherwise applied to
620 the new top-bases/... ref). The same rules apply to non-TopGit-controlled
621 dependencies. Use the ``tg update --base <branch> <new-ref>`` command to
622 safely make such an update while making it easy to set the merge commit
623 message at the same time.
625 Ignoring this rule and proceeding anyway with a non-fast-forward update to a
626 top-bases/... ref will result in changes present in the new value being merged
627 into the branch (at ``tg update`` time) as expected (possibly with conflicts),
628 but any changes that were contained in the old version of the top-bases/... ref
629 which have been dropped (i.e. are NOT contained in the new version of the
630 top-bases/... ref) will continue to be present in the branch! To get rid of
631 the dropped commits, one or more "revert" commits will have to be manually
632 applied to the tip of the new top-bases/... value (which will then be merged
633 into the branch at next ``tg update`` time).
635 The only time it's safe to amend, rebase, filter or otherwise rewrite commits
636 contained in a TopGit controlled branch or non-TopGit branch is when those
637 commits are NOT reachable via any other ref!
639 Furthermore, while it is safe to rewrite merge commits (provided they meet the
640 same conditions) the merge commits themselves and the branches they are merging
641 in must be preserved during the rewrite and that can be rather tricky to get
642 right so it's not recommended.
644 For example, if, while working on a TopGit-controlled branch ``foo``, a bad
645 typo is noticed, it's okay to ammend/rebase to fix that provided neither
646 ``tg update`` nor ``tg create`` has already been used to cause some other ref
647 to be able to reach the commit with the typo.
649 If an amend or rerwite is done anyway even though the commit with the typo is
650 reachable from some other ref, the typo won't really be removed. What will
651 happen instead is that the new version without the typo will ultimately be
652 merged into the other ref(s) (at ``tg update`` time) likely causing a conflict
653 that will have to be manually resolved and the commit with the typo will
654 continue to be reachable from those other refs!
656 Instead just make a new commit to fix the typo. The end result will end up
657 being the same but without the merge conflicts.
659 See also the discussion in the `NO UNDO`_ section.
665 A "TopGit bare branch" (or just "bare branch" for short), refers to a TopGit
666 branch that has neither a ``.topdeps`` nor a ``.topmsg`` file stored in it.
667 And it's neither a new, still-empty empty branch nor an annihilated branch.
669 Such branches are not recommended but are reluctantly accomodated.
671 There are three situtations in which TopGit may encounter a TopGit branch
672 that has neither a ``.topdeps`` nor a ``.topmsg`` file.
674 1. Branch creation with ``--no-commit``
675 Before the initial commit is made, the branch will still be
676 pointing to the same commit as its "top-bases" ref. Branches
677 in this condition (where the branch and top-bases ref point to
678 the same commit) show up as having "No commits" in listings.
680 2. Annihilated branches
681 A branch is annihilated by making a new commit on the branch
682 that makes its tree identical to the tree of its corresponding
683 top-bases ref. Although the trees will be the same, the
684 commits will be different and annihilated branches are
685 distinguished from "No commits" branches in this way.
686 Annihilated branches are generally invisible and do not show up
687 in listings or other status displays. Intentionally so.
690 Any TopGit branch with neither a ``.topdeps`` file nor a
691 ``.topmsg`` file whose branch and top-bases trees differ falls
692 into this category. TopGit will not create such a branch
693 itself nor does it provide any commands to do so.
695 Whenever possible, a TopGit "[BASE]" branch should be preferred to using a
696 "bare branch" because a) it can never be mistaken for an annihilated branch,
697 b) it has a nice subject attached (via its ``.topmsg`` file) that shows
698 up in listings and c) exactly when and which updates are taken can be planned.
700 Nevertheless, situations may arise where it's useful to have TopGit treat a
701 branch as a "TopGit branch" so that it fully participates in all update
702 activities (such as updating local branches based on their remote branches),
703 but it's not feasible to turn it into a real "TopGit branch" as it comes from
704 an external source and rather than controlling exactly when and what updates
705 are picked up from it by TopGit (the precise use case of a "[BASE]" branch),
706 all updates that appear on it are to be assimilated as soon as they occur.
708 For this reason, TopGit will accomodate such "bare branches" but it will not
709 create (nor provide the means to create) them itself.
711 In order to create a "bare branch" all that's required is to create the
712 necessary top-bases ref. The choice of commit for the top-bases ref will
713 affect the output of the "files", "log" and "patch" commands most directly
714 (but all commands will be affected).
716 To work properly as a "bare branch", the commit the "bare branch"'s base points
717 to should be contained within the branch, be a different commit than the branch
718 tip itself and have a different tree than the branch tip. Simply setting the
719 base to the parent commit of the "bare branch" will usually work, but should
720 that commit at the tip of the "bare branch" end up getting reverted as the next
721 commit, the trees would match and it would appear to be an annihilated branch
722 rather than a "bare branch". That is one of the reasons these branches are not
723 recommended in the first place.
725 Setting the base to the root commit of the branch is more reliable and may
726 be accomplished like so for a local branch named "mybranch":
730 git update-ref $(tg --top-bases)/mybranch \
731 $(git rev-list --first-parent --max-parents=0 mybranch) ""
733 Typically though it's more likely a remote bare branch will be needed. For
734 a remote named "origin" and a remote branch name of "vendor" this will do it:
738 git update-ref $(tg --top-bases -r origin)/vendor \
739 $(git rev-list --first-parent --max-parents=0 origin/vendor) ""
741 Such "bare branches" are not likely ever to receive any more direct support in
742 TopGit than acknowleging they can be useful in some situations and tolerating
743 their existence by functioning properly with them even to the point of the
744 ``pre-commit`` hook tacitly allowing continued commits on such branches without
745 complaints about missing ``.topdeps`` and ``.topmsg`` files.
747 Note, however, that creating a regular TopGit branch that has no changes of its
748 own with the "bare branch" as its single dependency provides a means to supply
749 some kind of documentation if all other uses of the "bare branch" depend on
750 this "wrapper" branch instead of directly on the "bare branch".
756 TopGit needs to check many things to determine whether a TopGit branch is
757 up-to-date or not. This can involve a LOT of git commands for a complex
758 dependency tree. In order to speed things up, TopGit keeps a cache of results
759 in a ``tg-cache`` subdirectory in the ``.git`` directory.
761 Results are tagged with the original hash values used to get that result so
762 that items which have not been changed return their results quickly and items
763 which have been changed compute their new result and cache it for future use.
765 The ``.git/tg-cache`` directory may be removed at any time and the cache will
766 simply be recreated in an on-demand fashion as needed, at some speed penalty,
767 until it's fully rebuilt.
769 To force the cache to be fully pre-loaded, run the ``tg summary`` command
770 without any arguments. Otherwise, normal day-to-day TopGit operations should
771 keep it more-or-less up-to-date.
773 While each TopGit command is running, it uses a temporary subdirectory also
774 located in the ``.git`` directory. These directories are named
775 ``tg-tmp.XXXXXX`` where the ``XXXXXX`` part will be random letters and digits.
777 These temporary directories should always be removed automatically after each
778 TopGit command finishes running. As long as you are not in a subshell as a
779 result of a TopGit command stopping and waiting for a manual merge resolution,
780 it's safe to remove any of these directories that may have somehow accidentally
781 been left behind as a result of some failure that occurred while running a
782 TopGit command (provided, of course, it's not actually being used by a TopGit
783 command currently running in another terminal window or by another user on the
789 ``tg [global options] <subcommand> [<subcommand option/argument>...]``
793 ``[-C <dir>]... [-r <remote> | -u] [-c <name>=<val>]... [--[no-]pager]``
795 -C <dir> Change directory to <dir> before doing anything more
796 -r <remote> Pretend ``topgit.remote`` is set to <remote>
797 -u Pretend ``topgit.remote`` is not set
798 -c <name=val> Pass config option to git, may be repeated
799 --no-pager Disable use of any pager (by both TopGit and Git)
800 --pager Enable use of a pager (aka ``-p``)
801 --top-bases Show full ``top-bases`` ref prefix and exit
802 --exec-path Show path to subcommand scripts location and exit
803 --help Show brief usage help and exit (aka ``-h``)
805 The ``tg`` tool has several subcommands:
807 :`tg annihilate`_: Mark a TopGit-controlled branch as defunct
808 :`tg base`_: Show base commit for one or more TopGit branches
809 :`tg checkout`_: Shortcut for git checkout with name matching
810 :`tg contains`_: Which TopGit-controlled branch contains the commit
811 :`tg create`_: Create a new TopGit-controlled branch
812 :`tg delete`_: Delete a TopGit-controlled branch cleanly
813 :`tg depend`_: Add a new dependency to a TopGit-controlled branch
814 :`tg export`_: Export TopGit branch patches to files or a branch
815 :`tg files`_: Show files changed by a TopGit branch
816 :`tg help`_: Show TopGit help optionally using a browser
817 :`tg import`_: Import commit(s) to separate TopGit branches
818 :`tg info`_: Show status information about a TopGit branch
819 :`tg log`_: Run git log limiting revisions to a TopGit branch
820 :`tg mail`_: Shortcut for git send-email with ``tg patch`` output
821 :`tg migrate-bases`_: Transition top-bases to new location
822 :`tg next`_: Show branches directly depending on a TopGit branch
823 :`tg patch`_: Generate a patch file for a TopGit branch
824 :`tg prev`_: Show non-annihilated TopGit dependencies for a branch
825 :`tg push`_: Run git push on TopGit branch(es) and depedencies
826 :`tg rebase`_: Auto continue git rebase if rerere resolves conflicts
827 :`tg remote`_: Set up remote for fetching/pushing TopGit branches
828 :`tg revert`_: Revert ref(s) to a state stored in a ``tg tag``
829 :`tg status`_: Show current TopGit status (e.g. in-progress update)
830 :`tg summary`_: Show various information about TopGit branches
831 :`tg tag`_: Create tag that records current TopGit branch state
832 :`tg update`_: Update TopGit branch(es) with respect to dependencies
836 Our sophisticated integrated help facility. Mostly duplicates
841 # to get help for a particular command:
843 # to get help for a particular command in a browser window:
844 $ tg help -w <command>
845 # to get help on TopGit itself
847 # to get help on TopGit itself in a browser
852 Our sophisticated status facility. Similar to Git's status command
853 but shows any in-progress update that's awaiting a merge resolution
854 or any other on-going TopGit activity (such as a branch creation).
856 With a single ``--verbose`` (or ``-v``) option include a short status
857 display for any dirty (but not untracked) files. This also causes all
858 non file status lines to be prefixed with "## ".
860 With two (or more) ``--verbose`` (or ``-v``) options, additionally
861 show full symbolic ref names and unabbreviated hash values.
863 With the ``--exit-code`` option the exit code will be non-zero if any
864 TopGit or Git operation is currently in progress or the working
869 Create a new TopGit-controlled topic branch of the given name
870 (required argument) and switch to it. If no dependencies are
871 specified (by extra arguments passed after the first one), the
872 current branch is assumed to be the only dependency.
874 By default ``tg create`` opens an editor on the new ``.topmsg`` file
875 and then commits the new ``.topmsg`` and ``.topdeps`` files
876 automatically with a suitable default commit message.
878 The commit message can be changed with the ``-m`` (or ``--message``) or
879 ``-F`` (or ``--file``) option. The automatic commit can be suppressed
880 by using the ``--no-ccmmit`` (or ``-n``) option. Running the editor on
881 the new ``.topmsg`` file can be suppressed by using ```--no-edit``
882 (which does *NOT* suppress the automatic commit unless ``--no-commit``
883 is also given) or by providing an explicit value for the new
884 ``.topmsg`` file using the ``--topmsg`` or ``--topmsg-file`` option.
885 In any case the ``.topmsg`` content will be automatically reformated to
886 have a ``Subject:`` header line if needed.
888 If the ``format.signoff`` config variable (see ``git help config``)
889 has been set to true then the ``Signed-off-by:`` header line added to
890 the end of the initial version of the ``.topmsg`` file will be
891 uncommented by default. Otherwise it will still be there but will be
892 commented out and will be automatically stripped if no action is taken
893 to remove the comment character.
895 If more than one dependency is listed an automatic ``tg update`` runs
896 after the branch has been created to merge in the additional
897 dependencies and bring the branch up-to-date. This can be suppressed
898 with the ``--no-commit`` option (which also suppresses the initial
899 commit) or the ``--no-update`` option (which allows the initial commit
900 while suppressing only the update operation portion).
902 Previous versions of TopGit behaved as though both the ``--no-edit``
903 and ``--no-commit`` options were always given on the command line.
905 The default behavior has been changed to promote a separation between
906 commits that modify ``.topmsg`` and/or ``.topdeps`` and commits that
907 modify other files. This facilitates cleaner cherry picking and other
908 patch maintenance activities.
910 You should edit the patch description (contained in the ``.topmsg``
911 file) as appropriate. It will already contain some prefilled bits.
912 You can set the ``topgit.to``, ``topgit.cc`` and ``topgit.bcc``
913 git configuration variables (see ``man git-config``) in order to
914 have ``tg create`` add these headers with the given default values
915 to ``.topmsg`` before invoking the editor. If the configuration
916 variable ``topgit.subjectPrefix`` is set its value will be inserted
917 *between* the initial ``[`` and the word ``PATCH`` in the subject
918 line (with a space added before the word ``PATCH`` of course).
920 The main task of ``tg create`` is to set up the topic branch base
921 from the dependencies. This may fail due to merge conflicts if more
922 than one dependency is given. In that case, after you commit the
923 conflict resolution, you should call ``tg update --continue`` to
924 finish merging the dependencies into the new topic branch base.
926 With the ``--base`` (aka ``--no-deps``) option at most one dependency
927 may be listed which may be any valid committish (instead of just
928 refs/heads/...) and the newly created TopGit-controlled branch will
929 have an empty ``.topdeps`` file. This may be desirable in order to
930 create a TopGit-controlled branch that has no changes of its own and
931 serves merely to mark the common dependency that all other
932 TopGit-controlled branches in some set of TopGit-controlled branches
933 depend on. A plain, non-TopGit-controlled branch can be used for the
934 same purpose, but the advantage of a TopGit-controlled branch with no
935 dependencies is that it will be pushed with ``tg push``, it will show
936 up in the ``tg summary`` and ``tg info`` output with the subject from
937 its ``.topmsg`` file thereby documenting what it's for and finally it
938 can be set up with ``tg create -r`` and/or ``tg remote --populate`` to
941 For example, ``tg create --base release v2.1`` will create a TopGit-
942 controlled ``release`` branch based off the ``v2.1`` tag that can then
943 be used as a base for creation of other TopGit-controlled branches.
944 Then when the time comes to move the base for an entire set of changes
945 up to ``v2.2`` the command ``tg update --base release v2.2`` can be
946 used followed by ``tg update --all``.
948 Using ``--base`` it's also possible to use ``tg create`` on an
949 unborn branch (omit the dependency name or specify ``HEAD``). The
950 unborn branch itself can be made into the new TopGit branch (rather
951 than being born empty and then having the new TopGit branch based off
952 that) by specifying ``HEAD`` as the new branch's name (which is
953 probably what you normally want to do in this case anyway so you can
954 just run ``tg create --base HEAD`` to accomplish that).
956 In an alternative use case, if ``-r <branch>`` is given instead of a
957 dependency list, the topic branch is created based on the given
958 remote branch. With just ``-r`` the remote branch name is assumed
959 to be the same as the local topic branch being created. Since no
960 new commits are created in this mode (only two refs will be updated)
961 the editor will never be run for this use case. Note that no other
962 options may be combined with ``-r``.
964 The ``--quiet`` (or ``-q``) option suppresses most informational
969 Remove a TopGit-controlled topic branch of the given name
970 (required argument). Normally, this command will remove only an
971 empty branch (base == head) without dependents; use ``-f`` to
972 remove a non-empty branch or a branch that is depended upon by
975 The ``-f`` option is also useful to force removal of a branch's
976 base, if you used ``git branch -D B`` to remove branch B, and then
977 certain TopGit commands complain, because the base of branch B
980 Normally ``tg delete`` will refuse to delete the current branch.
981 However, giving ``-f`` twice (or more) will force it to do so but it
982 will first detach your HEAD.
984 IMPORTANT: Currently, this command will *NOT* remove the branch
985 from the dependency list in other branches. You need to take
986 care of this *manually*. This is even more complicated in
987 combination with ``-f`` -- in that case, you need to manually
988 unmerge the removed branch's changes from the branches depending
991 The same ``--stash`` and ``--no-stash`` options are accepted with
992 the same exact semantics as for `tg update`_.
994 See also ``tg annihilate``.
996 | TODO: ``-a`` to delete all empty branches, depfix, revert
1000 Make a commit on the current or given TopGit-controlled topic
1001 branch that makes it equal to its base, including the presence or
1002 absence of .topmsg and .topdeps. Annihilated branches are not
1003 displayed by ``tg summary``, so they effectively get out of your
1004 way. However, the branch still exists, and ``tg push`` will
1005 push it (except if given the ``-a`` option). This way, you can
1006 communicate that the branch is no longer wanted.
1008 When annihilating a branch that has dependents (i.e. branches
1009 that depend on it), those dependents have the dependencies of
1010 the branch being annihilated added to them if they do not already
1011 have them as dependencies. Essentially the DAG is repaired to
1012 skip over the annihilated branch.
1014 Normally, this command will remove only an empty branch
1015 (base == head, except for changes to the .top* files); use
1016 ``-f`` to annihilate a non-empty branch.
1018 After completing the annihilation itself, normally ``tg update``
1019 is run on any modified dependents. Use the ``--no-update`` option
1020 to suppress running ``tg update``.
1022 The same ``--stash`` and ``--no-stash`` options are accepted with
1023 the same exact semantics as for `tg update`_.
1027 Change the dependencies of a TopGit-controlled topic branch.
1028 This should have several subcommands, but only ``add`` is
1029 supported right now.
1031 The ``add`` subcommand takes an argument naming a topic branch to
1032 be added, adds it to ``.topdeps``, performs a commit and then
1033 updates your topic branch accordingly. If you want to do other
1034 things related to the dependency addition, like adjusting
1035 ``.topmsg``, use the option ``--no-commit``. Adding the
1036 ``--no-update`` (or ``--no-commit``) option will suppress the
1037 ``tg update`` normally performed after committing the change.
1039 It is safe to run ``tg depend add`` in a dirty worktree, but the
1040 normally performed ``tg update`` will be suppressed in that case
1041 (even if neither ``--no-update`` nor ``--no-commit`` is given).
1043 You have enabled ``git rerere`` haven't you?
1045 | TODO: Subcommand for removing dependencies, obviously
1049 List files changed by the current or specified topic branch.
1052 -i list files based on index instead of branch
1053 -w list files based on working tree instead of branch
1057 Show summary information about the current or specified topic
1060 Numbers in parenthesis after a branch name such as "(11/3 commits)"
1061 indicate how many commits on the branch (11) and how many of those
1062 are non-merge commits (3).
1064 With ``--verbose`` (or ``-v``) include a list of dependents (i.e. other
1065 branches that depend on this one). Another ``--verbose`` annotates
1066 them with "[needs merge]" if the current tip of branch for which info
1067 is being shown has not yet been merged into the base of the dependent.
1069 Alternatively, if ``--heads`` is used then which of the independent
1070 TopGit branch heads (as output by ``tg summary --topgit-heads``)
1071 logically contains the specified commit (which may be any committish --
1072 defaults to ``HEAD`` if not given). Zero or more results will be
1073 output. Note that "logically" means with regard to the TopGit
1074 dependency relationships as established by the ``.topdeps`` file(s).
1075 It's the answer that would be given when all the TopGit branches are
1076 up-to-date (even though they need not be to use this option) and the
1077 ``git branch --contains`` command is run and the output then filtered
1078 to only those branches that appear in ``tg summary --topgit-heads``.
1079 This computation may require several seconds on complex repositories.
1081 If ``--leaves`` is used then the unique list of leaves of the current
1082 or specified topic branch is shown as one fully-qualified ref per line.
1083 Duplicates are suppressed and a tag name will be used when appropriate.
1084 A "leaf" is any dependency that is either not a TopGit branch or is
1085 the base of a non-annihilated TopGit branch with no non-annihilated
1088 The ``--deps`` option shows non-annihilated TopGit dependencies of the
1089 specified branch (default is ``HEAD``). (It can also be spelled out
1090 as ``--dependencies`` for the pedantically inclined.)
1092 The ``--dependents`` option shows non-annihilated TopGit dependents
1093 (i.e. branches that depend on the specified branch). The default
1094 branch to operate on is again ``HEAD``.
1096 A linearized patch series can only be automatically created for a
1097 TopGit topic branch (including its recursive dependencies) when exactly
1098 one line is output by ``tg info --leaves <topic-branch>``.
1100 With ``--series`` the list of TopGit branches in the order they would
1101 be linearized into a patch series is shown along with the description
1102 of each branch. If branch name passed to ``tg info`` is not the last
1103 branch in the series a marker column will be provided to quickly
1104 locate it in the list. This same option can be used with `tg checkout`_.
1106 Some patches shown in the list may not actually end up introducing any
1107 changes if exported and be therefore end up being omitted. The ``0``
1108 indicator in ``tg summary`` output can help to identify some of these.
1110 The patches shown in the series in the order they are shown form the
1111 basis for the ``tg next`` and ``tg prev`` operations with the first
1112 patch shown being considered the first and so on up to the last.
1116 Generate a patch from the current or specified topic branch.
1117 This means that the diff between the topic branch base and head
1118 (latest commit) is shown, appended to the description found in
1119 the ``.topmsg`` file.
1121 The patch is simply dumped to stdout. In the future, ``tg patch``
1122 will be able to automatically send the patches by mail or save
1123 them to files. (TODO)
1126 -i base patch generation on index instead of branch
1127 -w base patch generation on working tree instead of branch
1128 --binary pass --binary to ``git diff-tree`` to enable generation
1130 --quiet be quiet (aka ``-q``) about missing and unfixed From:
1131 --from make sure patch has a From: line, if not add one
1132 --from=<a> <a> or Signed-off-by value or ident value; ``git am``
1133 really gets unhappy with patches missing From: lines;
1134 will NOT replace an existing non-empty From: header
1135 --no-from leave all From: lines alone, missing or not (default)
1136 --diff-opt options after the branch name (and an optional ``--``)
1137 are passed directly to ``git diff-tree``
1139 In order to pass a sole explicit ``-w`` through to ``git diff-tree`` it
1140 must be separated from the ``tg`` options by an explicit ``--``.
1141 Or it can be spelled as ``--ignore-all-space`` to distinguuish it from
1142 ``tg``'s ``-w`` option.
1144 If the config variable ``topgit.from`` is set to a boolean it can be
1145 used to enable or disable the ``--from`` option by default. If it's
1146 set to the special value ``quiet`` the ``--quiet`` option is enabled
1147 and From: lines are left alone by default. Any other non-empty value
1148 is taken as a default ``--from=<value>`` option. The ``--no-from``
1149 option will temporarily disable use of the config value.
1151 If additional non-``tg`` options are passed through to
1152 ``git diff-tree`` (other than ``--binary`` which is fully supported)
1153 the resulting ``tg patch`` output may not be appliable.
1157 Send a patch from the current or specified topic branch as
1160 Takes the patch given on the command line and emails it out.
1161 Destination addresses such as To, Cc and Bcc are taken from the
1164 Since it actually boils down to ``git send-email``, please refer
1165 to the documentation for that for details on how to setup email
1166 for git. You can pass arbitrary options to this command through
1167 the ``-s`` parameter, but you must double-quote everything. The
1168 ``-r`` parameter with a msgid can be used to generate in-reply-to
1169 and reference headers to an earlier mail.
1171 WARNING: be careful when using this command. It easily sends
1172 out several mails. You might want to run::
1174 git config sendemail.confirm always
1176 to let ``git send-email`` ask for confirmation before sending any
1180 -i base patch generation on index instead of branch
1181 -w base patch generation on working tree instead of branch
1183 | TODO: ``tg mail patchfile`` to mail an already exported patch
1184 | TODO: mailing patch series
1185 | TODO: specifying additional options and addresses on command line
1189 Register the given remote as TopGit-controlled. This will create
1190 the namespace for the remote branch bases and teach ``git fetch``
1191 to operate on them. However, from TopGit 0.8 onwards you need to
1192 use ``tg push``, or ``git push --mirror``, for pushing
1193 TopGit-controlled branches.
1195 ``tg remote`` takes an optional remote name argument, and an
1196 optional ``--populate`` switch. Use ``--populate`` for your
1197 origin-style remotes: it will seed the local topic branch system
1198 based on the remote topic branches. ``--populate`` will also make
1199 ``tg remote`` automatically fetch the remote, and ``tg update`` look
1200 at branches of this remote for updates by default.
1202 Using ``--populate`` with a remote name causes the ``topgit.remote``
1203 git configuration variable to be set to the given remote name.
1207 Show overview of all TopGit-tracked topic branches and their
1208 up-to-date status. With a branch name limit output to that branch.
1209 Using ``--deps-only`` or ``--rdeps`` changes the default from all
1210 branches to just the current ``HEAD`` branch but using ``--all`` as
1211 the branch name will show results for all branches instead of ``HEAD``.
1214 marks the current topic branch
1217 indicates that it introduces no changes of its own
1220 indicates respectively whether it is local-only
1221 or has a remote mate
1224 indicates respectively if it is ahead or out-of-date
1225 with respect to its remote mate
1228 indicates that it is out-of-date with respect to its
1232 indicates that it has missing dependencies [even if
1233 they are recursive ones]
1236 indicates that it is out-of-date with respect to
1240 indicates it is ahead of (and needs to be merged into)
1241 at least one of its dependents -- only computed when
1242 showing all branches or using the (possibly implied)
1243 ``--with-deps`` option.
1245 This can take a longish time to accurately determine all the
1246 relevant information about each branch; you can pass ``-t`` (or ``-l``
1247 or ``--list``) to get just a terse list of topic branch names quickly.
1248 Also adding ``--verbose`` (or ``-v``) includes the subjects too.
1249 Adding a second ``--verbose`` includes annihilated branches as well.
1251 Passing ``--heads`` shows independent topic branch names and when
1252 combined with ``--rdeps`` behaves as though ``--rdeps`` were run with
1253 the output of ``--heads``.
1255 The ``--heads-independent`` option works just like ``--heads`` except
1256 that it computes the heads using ``git merge-base --independent``
1257 rather than examining the TopGit ``.topdeps`` relationships. If the
1258 TopGit branches are all up-to-date (as shown in ``tg summary``) then
1259 both ``--heads`` and ``--heads-independent`` should compute the same
1260 list of heads (unless some overlapping TopGit branches have been
1261 manually created). If not all the TopGit branches are up-to-date then
1262 the ``--heads-independent`` results may have extra items in it, but
1263 occasionally that's what's needed; usually it's the wrong answer.
1264 (Note that ``--topgit-heads`` is accepted as an alias for ``--heads``
1267 Using ``--heads-only`` behaves as though the output of ``--heads`` was
1268 passed as the list of branches along with ``--without-deps``.
1270 Alternatively, you can pass ``--graphviz`` to get a dot-suitable output
1271 for drawing a dependency graph between the topic branches.
1273 You can also use the ``--sort`` option to sort the branches using
1274 a topological sort. This is especially useful if each
1275 TopGit-tracked topic branch depends on a single parent branch,
1276 since it will then print the branches in the dependency order.
1277 In more complex scenarios, a text graph view would be much more
1278 useful, but that has not yet been implemented.
1280 The ``--deps`` option outputs dependency information between
1281 branches in a machine-readable format. Feed this to ``tsort`` to
1282 get the output from --sort.
1284 The ``--deps-only`` option outputs a sorted list of the unique branch
1285 names given on the command line plus all of their recursive
1286 dependencies (subject to ``--exclude`` of course). When
1287 ``--deps-only`` is given the default is to just display information for
1288 ``HEAD``, but that can be changed by using ``--all`` as the branch
1289 name. Each branch name will appear only once in the output no matter
1290 how many times it's visited while tracing the dependency graph or how
1291 many branch names are given on the command line to process.
1293 The ``--rdeps`` option outputs dependency information in an indented
1294 text format that clearly shows all the dependencies and their
1295 relationships to one another. When ``--rdeps`` is given the default is
1296 to just display information for ``HEAD``, but that can be changed by
1297 using ``--all`` as the branch name or by adding the ``--heads`` option.
1298 Note that ``tg summary --rdeps --heads`` can be particularly helpful in
1299 seeing all the TopGit-controlled branches in the repository and their
1300 relationships to one another.
1302 Note that ``--rdeps`` has two flavors. The first (and default) is
1303 ``--rdeps-once`` which only shows the dependencies of a branch when
1304 it's first visited. For example, if D depends on several other
1305 branches perhaps recursively and both branch A and B depend on D, then
1306 whichever of A or B is shown first will show the entire dependency
1307 chain for D underneath it and the other one will just show a line for
1308 D itself with a "^" appended to indicate that the rest of the deps for
1309 D can be found above. This can make the output a bit more compact
1310 without actually losing any information which is why it's the default.
1311 However, using the ``--rdeps-full`` variant will repeat the full
1312 dependency chain every time it's encountered.
1314 Adding ``--with-deps`` replaces the given list of branches (which will
1315 default to ``HEAD`` if none are given) with the result of running
1316 ``tg summary --deps-only --tgish`` on the list of branches. This can
1317 be helpful in limiting ``tg summary`` output to only the list of given
1318 branches and their dependencies when many TopGit-controlled branches
1319 are present in the repository. Use ``--without-deps`` to switch back
1320 to the old behavior.
1322 The ``--with-related`` option extends (and therefore implies)
1323 ``--with-deps``. First the list of branches (which will default to
1324 ``HEAD`` if none are given) is replaced with the result of running
1325 ``tg summary --heads`` (aka ``--topgit-heads``) and the result is then
1326 processed as though it had been specified using ``--with-deps``.
1328 When it would be allowed, ``--with-deps`` is now the default. But,
1329 if in addition, exactly one branch is specified (either explicitly
1330 or implicitly) and it's spelled *exactly* as ``HEAD`` or ``@`` then
1331 the default ``--with-deps`` will be promoted to a default
1332 ``--with-related`` instead. Since duplicate branches are removed
1333 before processing, explicitly listing ``@`` twice provides an easy way
1334 to defeat this automatic promotion and ask for ``--with-deps`` on the
1335 ``HEAD`` symbolic ref with minimal typing when ``--with-related`` isn't
1336 really wanted and typing the full ``--with-deps`` option is too hard.
1338 With ``--exclude branch``, branch can be excluded from the output
1339 meaning it will be skipped and its name will be omitted from any
1340 dependency output. The ``--exclude`` option may be repeated to omit
1341 more than one branch from the output. Limiting the output to a single
1342 branch that has been excluded will result in no output at all.
1344 The ``--tgish-only`` option behaves as though any non-TopGit-controlled
1345 dependencies encountered during processing had been listed after an
1346 ``--exclude`` option.
1348 Note that the branch name can be specified as ``HEAD`` or ``@`` as a
1349 shortcut for the TopGit-controlled branch that ``HEAD`` is a
1350 symbolic ref to. The ``tg summary @`` and ``tg summary @ @`` commands
1351 can be quite useful.
1354 -i Use TopGit metadata from the index instead of the branch
1355 -w Use TopGit metadata from the working tree instead of the branch
1359 Search all TopGit-controlled branches (and optionally their remotes)
1360 to find which TopGit-controlled branch contains the specified commit.
1362 This is more than just basic branch containment as provided for by the
1363 ``git branch --contains`` command. While the shown branch name(s)
1364 will, indeed, be one (or more) of those output by the
1365 ``git branch --contains`` command, the result(s) will exclude any
1366 TopGit-controlled branches from the result(s) that have one (or more)
1367 of their TopGit dependencies (either direct or indirect) appearing in
1368 the ``git branch --contains`` output.
1370 Normally the result will be only the one, single TopGit-controlled
1371 branch for which the specified committish appears in the ``tg log``
1372 output for that branch (unless the committish lies outside the
1373 TopGit-controlled portion of the DAG and ``--no-strict`` was used).
1375 Unless ``--annihilated-okay`` (or ``--ann`` or ``--annihilated``) is
1376 used then annihilated branches will be immediately removed from the
1377 ``git branch --contains`` output before doing anything else. This
1378 means a committish that was originally located in a now-annihilated
1379 branch will show up in whatever branch picked up the annihilated
1380 branch's changes (if there is one). This is usually the correct
1381 answer, but occasionally it's not; hence this option. If this option
1382 is used together with ``--verbose`` then annihilated branches will
1383 be shown as "[:annihilated:]".
1385 In other words, if a ``tg patch`` is generated for the found branch
1386 (assuming one was found and a subsequent commit in the same branch
1387 didn't then revert or otherwise back out the change), then that patch
1388 will include the changes introduced by the specified committish
1389 (unless, of course, that committish is outside the TopGit-controlled
1390 portion of the DAG and ``--no-strict`` was given).
1392 This can be very helpful when, for example, a bug is discovered and
1393 then after using ``git bisect`` (or some other tool) to find the
1394 offending commit it's time to commit the fix. But because the
1395 TopGit merging history can be quite complicated and maybe the one
1396 doing the fix wasn't the bug's author (or the author's memory is just
1397 going), it can sometimes be rather tedious to figure out which
1398 TopGit branch the fix belongs in. The ``tg contains`` command can
1399 quickly tell you the answer to that question.
1401 With the ``--remotes`` (or ``-r``) option a TopGit-controlled remote
1402 branch name may be reported as the result but only if there is no
1403 non-remote branch containing the committish (this can only happen
1404 if at least one of the TopGit-controlled local branches are not yet
1405 up-to-date with their remotes).
1407 With the ``--verbose`` option show which TopGit DAG head(s) (one or
1408 more of the TopGit-controlled branch names output by
1409 ``tg summary --heads``) have the result as a dependency (either direct
1410 or indirect). Using this option will noticeably increase running time.
1412 With the default ``--strict`` option, results for which the base of the
1413 TopGit-controlled branch contains the committish will be suppressed.
1414 For example, if the committish was deep-down in the master branch
1415 history somewhere far outside of the TopGit-controlled portion of
1416 the DAG, with ``--no-strict``, whatever TopGit-controlled branch(es)
1417 first picked up history containing that committish will be shown.
1418 While this is a useful result it's usually not the desired result
1419 which is why it's not the default.
1421 To summarize, even with ``--remotes``, remote results are only shown
1422 if there are no non-remote results. Without ``--no-strict`` (because
1423 ``--strict`` is the default) results outside the TopGit-controlled
1424 portion of the DAG are never shown and even with ``--no-strict`` they
1425 will only be shown if there are no ``--strict`` results. Finally,
1426 the TopGit head info shown with ``--verbose`` only ever appears for
1427 local (i.e. not a remote branch) results. Annihilated branches are
1428 never considered possible matches without ``--annihilated-okay``.
1432 Switch to a topic branch. You can use ``git checkout <branch>``
1433 to get the same effect, but this command helps you navigate
1434 the dependency graph, or allows you to match the topic branch
1435 name using a regular expression, so it can be more convenient.
1437 The ``--branch`` (or ``-b`` or ``--branch=<name>``) option changes
1438 the default starting point from ``HEAD`` to the specified branch.
1440 For the "next" and "previous" commands, the ``<steps>`` value may
1441 be ``--all`` (or ``-a``) to take "As many steps As possible" or
1442 "step ALL the way" or "ALL steps at once" (or make something better
1445 The following subcommands are available:
1447 ``tg checkout next [<steps>]``
1448 Check out a branch that directly
1449 depends on your current branch.
1450 Move ``<steps>`` (default 1) step(s) in
1451 the "next" direction (AKA ``n``).
1453 ``tg checkout prev [<steps>]``
1454 Check out a branch that this branch
1455 directly depends on. Move ``<steps>``
1456 (default 1) step(s) in the "previous"
1457 direction (AKA ``p`` or ``previous``).
1459 ``tg checkout [goto] [--] <pattern>``
1460 Check out a topic branch that
1461 matches ``<pattern>``. ``<pattern>``
1462 is used as a grep ERE pattern to filter
1463 all the topic branches. Both ``goto`` and
1464 ``--`` may be omitted provided ``<pattern>``
1465 is not ``-a``, ``--all``, ``-h``, ``--help``,
1466 ``goto``, ``--``, ``n``, ``next``, ``push``,
1467 ``child``, ``p``, ``prev``, ``previous``,
1468 ``pop``, ``parent`` or ``..``.
1470 ``tg checkout [goto] [--] --series[=<head>]``
1471 Check out a topic branch that belongs to
1472 the current (or ``<head>``) patch series.
1473 A list with descriptions (``tg info --series``)
1474 will be shown to choose from if more than one.
1476 ``tg checkout push [<steps>]``
1477 An alias for ``next``.
1479 ``tg checkout child [<steps>]``
1480 Deprecated alias for ``next``.
1483 Semi-deprecated alias for ``next``.
1485 ``tg checkout pop [<steps>]``
1486 An alias for ``prev``.
1488 ``tg checkout parent [<steps>]``
1489 Deprecated alias for ``prev``.
1491 ``tg checkout .. [<steps>]``
1492 Semi-deprecated alias for ``prev``.
1494 If any of the above commands can find more than one possible
1495 branch to switch to, you will be presented with the matches
1496 and asked to select one of them.
1498 If the ``--ignore-other-worktrees`` (or ``--iow``) option is given and
1499 the current Git version is at least 2.5.0 then the full
1500 ``--ignore-other-worktrees`` option will be passed along to the
1501 ``git checkout`` command when it's run (otherwise the option will be
1502 silently ignored and not passed to Git as it would cause an error).
1504 The ``--force`` (or ``-f``) option, when given, gets passed through to
1505 the ``git checkout`` command.
1507 The ``--merge`` (or ``-m``) option, when given, gets passed through to
1508 the ``git checkout`` command.
1510 The ``--quiet`` (or ``-q``) option, when given, gets passed through to
1511 the ``git checkout`` command.
1513 The ``<pattern>`` of ``tg checkout goto`` is optional. If you don't
1514 supply it, all the available topic branches are listed and you
1515 can select one of them.
1517 Normally, the ``next`` and ``prev`` commands moves one step in
1518 the dependency graph of the topic branches. The ``-a`` option
1519 causes them (and their aliases) to move as far as possible.
1520 That is, ``tg checkout next -a`` moves to a topic branch that
1521 depends (directly or indirectly) on the current branch and
1522 that no other branch depends on. ``tg checkout prev -a``
1523 moves to a topic branch that the current topic branch
1524 depends on (directly or indirectly). If there is more than
1525 one possibility, you will be prompted for your selection.
1527 See also NAVIGATION_.
1531 Export a tidied-up history of the current topic branch and its
1532 dependencies, suitable for feeding upstream. Each topic branch
1533 corresponds to a single commit or patch in the cleaned up
1534 history (corresponding basically exactly to ``tg patch`` output
1535 for the topic branch).
1537 The command has three possible outputs now -- either a Git branch
1538 with the collapsed history, a Git branch with a linearized
1539 history, or a quilt series in new directory.
1541 In the case where you are producing collapsed history in a new
1542 branch, you can use this collapsed structure either for
1543 providing a pull source for upstream, or for further
1544 linearization e.g. for creation of a quilt series using git log::
1546 git log --pretty=email -p --topo-order origin..exported
1548 To better understand the function of ``tg export``, consider this
1549 dependency structure::
1551 origin/master - t/foo/blue - t/foo/red - master
1552 `- t/bar/good <,----------'
1553 `- t/baz ------------'
1555 (where each of the branches may have a hefty history). Then::
1557 master$ tg export for-linus
1559 will create this commit structure on the branch ``for-linus``::
1561 origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
1562 `- t/bar/good <,-------------------'/
1563 `- t/baz ---------------------'
1565 In this mode, ``tg export`` works on the current topic branch, and
1566 can be called either without an option (in that case,
1567 ``--collapse`` is assumed), or with the ``--collapse`` option, and
1568 with one mandatory argument: the name of the branch where the
1569 exported result will be stored.
1571 When using the linearize mode::
1573 master$ tg export --linearize for-linus
1575 you get a linear history respecting the dependencies of your
1576 patches in a new branch ``for-linus``. The result should be more
1577 or less the same as using quilt mode and then reimporting it
1578 into a Git branch. (More or less because the topological order
1579 can usually be extended in more than one way into a total order,
1580 and the two methods may choose different ones.) The result
1581 might be more appropriate for merging upstream, as it contains
1584 Note that you might get conflicts during linearization because
1585 the patches are reordered to get a linear history. If linearization
1586 would produce conflicts then using ``--quilt`` will also likely result
1587 in conflicts when the exported quilt series is applied. Since the
1588 ``--quilt`` mode simply runs a series of ``tg patch`` commands to
1589 generate the patches in the exported quilt series and those patches
1590 will end up being applied linearly, the same conflicts that would be
1591 produced by the ``--linearize`` option will then occur at that time.
1593 To avoid conflicts produced by ``--linearize`` (or by applying the
1594 ``--quilt`` output), use the default ``--collapse`` mode and then use
1595 ``tg rebase`` (or ``git rebase -m`` directly) on the collapsed branch
1596 (with a suitable <upstream>) followed by ``git format-patch`` on the
1597 rebased result to produce a conflict-free patch set. A suitable
1598 upstream may be determined with the ``tg info --leaves`` command (if
1599 it outputs more than one line, linearization will be problematic).
1601 You have enabled ``git rerere`` haven't you?
1603 When using the quilt mode::
1605 master$ tg export --quilt for-linus
1607 would create the following directory ``for-linus``::
1609 for-linus/t/foo/blue.diff
1610 for-linus/t/foo/red.diff
1611 for-linus/t/bar/good.diff
1612 for-linus/t/baz.diff
1619 With ``--quilt``, you can also pass the ``-b`` parameter followed
1620 by a comma-separated explicit list of branches to export, or
1621 the ``--all`` parameter (which can be shortened to ``-a``) to
1622 export them all. The ``--binary`` option enables producing Git
1623 binary patches. These options are currently only supported
1626 In ``--quilt`` mode the patches are named like the originating
1627 topgit branch. So usually they end up in subdirectories of the
1628 output directory. With the ``--flatten`` option the names are
1629 mangled so that they end up directly in the output dir (slashes
1630 are replaced with underscores). With the ``--strip[=N]`` option
1631 the first ``N`` subdirectories (all if no ``N`` is given) get
1632 stripped off. Names are always ``--strip``'d before being
1633 ``--flatten``'d. With the option ``--numbered`` (which implies
1634 ``--flatten``) the patch names get a number as prefix to allow
1635 getting the order without consulting the series file, which
1636 eases sending out the patches.
1638 | TODO: Make stripping of non-essential headers configurable
1639 | TODO: Make stripping of [PATCH] and other prefixes configurable
1640 | TODO: ``--mbox`` option to export instead as an mbox file
1641 | TODO: support ``--all`` option in other modes of operation
1642 | TODO: For quilt exporting, export the linearized history created in
1643 a temporary branch--this would allow producing conflict-less
1648 Import commits within the given revision range(s) into TopGit,
1649 creating one topic branch per commit. The dependencies are set
1650 up to form a linear sequence starting on your current branch --
1651 or a branch specified by the ``-d`` parameter, if present.
1653 The branch names are auto-guessed from the commit messages and
1654 prefixed by ``t/`` by default; use ``-p <prefix>`` to specify an
1655 alternative prefix (even an empty one).
1657 Each "<range>" must be of the form <rev1>..<rev2> where either
1658 <rev1> or <rev2> can be omitted to mean HEAD. Additionally the
1659 shortcut <rev>^! (see ``git help revisions``) is permitted as a
1660 "<range>" to select the single commit <rev> but only if the
1661 commit <rev> has *exactly* one parent. This is really just a
1662 shortcut for <rev>^..<rev> but somewhat safer since it will fail
1663 if <rev> has other than one parent.
1665 Alternatively, you can use the ``-s NAME`` parameter to specify
1666 the name of the target branch; the command will then take one
1667 more argument describing a *single* commit to import (which may
1668 have any number of parents).
1672 Update the current, specified or all topic branches with respect
1673 to changes in the branches they depend on and remote branches.
1674 This is performed in two phases -- first, changes within the
1675 dependencies are merged to the base, then the base is merged
1676 into the topic branch. The output will guide you on what to do
1677 next in case of conflicts.
1679 You have enabled ``git rerere`` haven't you?
1681 The ``--[no-]auto[-update]`` options together with the
1682 ``topgit.setAutoUpdate`` config item control whether or not TopGit
1683 will automatically temporarily set ``rerere.autoUpdate`` to true while
1684 running ``tg update``. The default is true. Note that this does not
1685 enable Git's ``rerere`` feature, it merely makes it automatically stage
1686 any previously resolved conflicts. The ``rerere.enabled`` setting must
1687 still be separately enabled (i.e. set to ``true``) for the ``rerere``
1688 feature to do anything at all.
1690 Using ``--auto[-update]`` makes ``tg update`` always temporarily set
1691 ``rerere.autoUpdate`` to ``true`` while running ``tg update``. The
1692 ``--no-auto[-update]`` option prevents ``tg update`` from changing the
1693 ``rerere.autoUpdate`` setting, but if ``rerere.autoUpdate`` has already
1694 been enabled in a config file, ``tg update`` never disables it even
1695 with ``--no-auto``. If ``topgit.setAutoUpdate`` is unset or set to
1696 ``true`` then ``tg update`` implicitly does ``--auto``, otherwise it
1697 does ``--no-auto``. An explicit command line ``--[no-]auto[-update]``
1698 option causes the ``topgit.setAutoUpdate`` setting to be ignored.
1700 When both ``rerere.enabled`` and ``rerere.autoUpdate`` are set to true
1701 then ``tg update`` will be able to automatically continue an update
1702 whenever ``git rerere`` resolves all the conflicts during a merge.
1703 This can be such a huge time saver. That's why the default is to have
1704 TopGit automatically set ``rerere.autoUpdate`` to true while
1705 ``tg update`` is running (but remember, unless ``rerere.enabled`` has
1706 been set to ``true`` it won't make any difference).
1708 When ``-a`` (or ``--all``) is specified, updates all topic branches
1709 matched by ``<pattern>``'s (see ``git-for-each-ref(1)`` for details),
1710 or all if no ``<pattern>`` is given. Any topic branches with missing
1711 dependencies will be skipped entirely unless ``--skip-missing`` is
1714 When ``--skip-missing`` is specified, an attempt is made to update topic
1715 branches with missing dependencies by skipping only the dependencies
1716 that are missing. Caveat utilitor.
1718 When ``--stash`` is specified (or the ``topgit.autostash`` config
1719 value is set to ``true``), a ref stash will be automatically created
1720 just before beginning updates if any are needed. The ``--no-stash``
1721 option may be used to disable a ``topgit.autostash=true`` setting.
1722 See the ``tg tag`` ``--stash`` option for details.
1724 After the update, if a single topic branch was specified, it is
1725 left as the current one; if ``-a`` was specified, it returns to
1726 the branch which was current at the beginning.
1728 If your dependencies are not up-to-date, ``tg update`` will first
1729 recurse into them and update them.
1731 If a remote branch update brings in dependencies on branches
1732 that are not yet instantiated locally, you can either bring in
1733 all the new branches from the remote using ``tg remote
1734 --populate``, or only pick out the missing ones using ``tg create
1735 -r`` (``tg summary`` will point out branches with incomplete
1736 dependencies by showing an ``!`` next to them). TopGit will attempt to
1737 instantiate just the missing ones automatically for you, if possible,
1738 when ``tg update`` merges in the new dependencies from the remote.
1740 Using the alternative ``--base`` mode, ``tg update`` will update
1741 the base of a specified ``[BASE]`` branch (which is a branch created
1742 by ``tg create`` using the ``--base`` option) to the specified
1743 committish (the second argument) and then immediately merge that into
1744 the branch itself using the specified message for the merge commit.
1745 If no message is specified on the command line, an editor will open.
1746 Unless ``--force`` is used the new value for the base must contain
1747 the old value (i.e. be a fast-forward update). This is for safety.
1749 This mode makes updates to ``[BASE]`` branches quick and easy.
1751 | TODO: ``tg update -a -c`` to autoremove (clean) up-to-date branches
1755 If ``-a`` or ``--all`` was specified, pushes all non-annihilated
1756 TopGit-controlled topic branches, to a remote repository.
1757 Otherwise, pushes the specified topic branches -- or the
1758 current branch, if you don't specify which. By default, the
1759 remote gets all the dependencies (both TopGit-controlled and
1760 non-TopGit-controlled) and bases pushed to it too. If
1761 ``--tgish-only`` was specified, only TopGit-controlled
1762 dependencies will be pushed, and if ``--no-deps`` was specified,
1763 no dependencies at all will be pushed.
1765 The ``--dry-run`` and ``--force`` options are passed directly to
1766 ``git push`` if given.
1768 The remote may be specified with the ``-r`` option. If no remote
1769 was specified, the configured default TopGit remote will be
1774 Prints the base commit of each of the named topic branches, or
1775 the current branch if no branches are named. Prints an error
1776 message and exits with exit code 1 if the named branch is not
1781 Prints the git log of the named topgit branch -- or the current
1782 branch, if you don't specify a name.
1784 This is really just a convenient shortcut for:
1786 ``git log --first-parent --no-merges $(tg base <name>)..<name>``
1788 where ``<name>`` is the name of the TopGit topic branch (or omitted
1789 for the current branch).
1791 However, if ``<name>`` is a ``[BASE]`` branch the ``--no-merges``
1794 If ``--compact`` is used then ``git log-compact`` will be used instead
1795 of ``git log``. The ``--command=<git-alias>`` option can be used to
1796 replace "log" with any non-whitespace-containing command alias name,
1797 ``--compact`` is just a shortcut for ``--command=log-compact``. The
1798 ``git-log-compact`` tool may be found on its project page located at:
1800 https://mackyle.github.io/git-log-compact
1802 Note that the ``--compact`` or ``--command=`` option must be used
1803 before any ``--`` or ``git log`` options to be recognized.
1805 NOTE: if you have merged changes from a different repository, this
1806 command might not list all interesting commits.
1810 Creates a TopGit annotated/signed tag or lists the reflog of one.
1812 A TopGit annotated tag records the current state of one or more TopGit
1813 branches and their dependencies and may be used to revert to the tagged
1814 state at any point in the future.
1816 When reflogs are enabled (the default in a non-bare repository) and
1817 combined with the ``--force`` option a single tag name may be used as a
1818 sort of TopGit branch state stash. The special branch name ``--all``
1819 may be used to tag the state of all current TopGit branches to
1820 facilitate this function and has the side-effect of suppressing the
1821 out-of-date check allowing out-of-date branches to be included.
1823 As a special feature, ``--stash`` may be used as the tag name in which
1824 case ``--all`` is implied if no branch name is listed (instead of the
1825 normal default of ``HEAD``), ``--force`` and ``--no-edit`` (use
1826 ``--edit`` to change that) are automatically activated and the tag will
1827 be saved to ``refs/tgstash`` instead of ``refs/tags/<tagname>``.
1828 The ``--stash`` tag name may also be used with the ``-g``/``--reflog``
1831 The mostly undocumented option ``--allow-outdated`` will bypass the
1832 out-of-date check and is implied when ``--stash`` or ``--all`` is used.
1834 A TopGit annotated/signed tag is simply a Git annotated/signed tag with
1835 a "TOPGIT REFS" section appended to the end of the tag message (and
1836 preceding the signature for signed tags). PEM-style begin and end
1837 lines surround one line per ref where the format of each line is
1838 full-hash SP ref-name. A line will be included for each branch given
1839 on the command line and each ref they depend on either directly or
1842 If more than one TopGit branch is given on the command line, a new
1843 commit will be created that has an empty tree and all of the given
1844 TopGit branches as parents and that commit will be tagged. If a single
1845 TopGit branch is given, then it will be tagged. If the ``--tree``
1846 option is used then it will be used instead of an empty tree (a new
1847 commit will be created if necessary to guarantee the specified tree is
1848 what's in the commit the newly created tag refers to). The argument to
1849 the ``--tree`` option may be any valid treeish.
1851 If exactly one of the branches to be tagged is prefixed with a tilde
1852 (``~``) it will be made the first parent of a consolidation commit if
1853 it is not already the sole commit needing to be tagged. If ``--tree``
1854 is NOT used, its tree will also be used instead of the empty tree for
1855 any new consolidation commit if one is created. Note that if
1856 ``--tree`` is given explicitly it's tree is always used but that does
1857 not in any way affect the choice of first parent. Beware that the
1858 ``~`` may need to be quoted to prevent the shell from misinterpreting
1859 it into something else.
1861 All the options for creating a tag serve the same purpose as their Git
1862 equivalents except for two. The ``--refs`` option suppresses tag
1863 creation entirely and emits the "TOPGIT REFS" section that would have
1864 been included with the tag. If the ``--no-edit`` option is given and
1865 no message is supplied (via the ``-m`` or ``-F`` option) then the
1866 default message created by TopGit will be used without running the
1869 With ``-g`` or ``--reflog`` show the reflog for a tag. With the
1870 ``--reflog-message`` option the message from the reflog is shown.
1871 With the ``--commit-message`` option the first line of the tag's
1872 message (if the object is a tag) or the commit message (if the object
1873 is a commit) falling back to the reflog message for tree and blob
1874 objects is shown. The default is ``--reflog-message`` unless the
1875 ``--stash`` (``refs/tgstash``) is being shown in which case the default
1876 is then ``--commit-message``. Just add either option explicitly to
1877 override the default.
1879 When showing reflogs, non-tag entries are annotated with their type
1880 unless ``--no-type`` is given.
1882 TopGit tags are created with a reflog if core.logallrefupdates is
1883 enabled (the default for non-bare repositories). Unfortunately Git
1884 is incapable of showing an annotated/signed tag's reflog
1885 (using git log -g) as it will first resolve the tag before checking to
1886 see if it has a reflog. Git can, however, show reflogs for lightweight
1887 tags (using git log -g) just fine but that's not helpful here. Use
1888 ``tg tag`` with the ``-g`` or ``--reflog`` option to see the reflog for
1889 an actual tag object. This also works on non-TopGit annotated/signed
1890 tags as well provided they have a reflog.
1892 The number of entries shown may be limited with the ``-n`` option. If
1893 the tagname is omitted then ``--stash`` is assumed.
1895 The ``--delete`` option is a convenience option that runs the
1896 ``git update-ref -d`` command on the specified tag removing it and its
1897 reflog (if it has one).
1899 The ``--clear`` option clears all but the most recent (the ``@{0}``)
1900 reflog entries from the reflog for the specified tag. It's equivalent
1901 to dropping all the higher numbered reflog entries.
1903 The ``--drop`` option drops the specified reflog entry and requires the
1904 given tagname to have an ``@{n}`` suffix where ``n`` is the reflog
1905 entry number to be dropped. This is really just a convenience option
1906 that runs the appropriate ``git reflog delete`` command.
1908 Note that when combined with ``tg revert``, a tag created by ``tg tag``
1909 can be used to transfer TopGit branches. Simply create the tag, push
1910 it somewhere and then have the recipient run ``tg revert`` to recreate
1911 the TopGit branches. This may be helpful in situations where it's not
1912 feasible to push all the refs corresponding to the TopGit-controlled
1913 branches and their top-bases.
1917 Provides a ``git rebase`` rerere auto continue function. It may be
1918 used as a drop-in replacement front-end for ``git rebase -m`` that
1919 automatically continues the rebase when ``git rerere`` information is
1920 sufficient to resolve all conflicts.
1922 You have enabled ``git rerere`` haven't you?
1924 If the ``-m`` or ``--merge`` option is not present then ``tg rebase``
1925 will complain and not do anything.
1927 When ``git rerere`` is enabled, previously resolved conflicts are
1928 remembered and can be automatically staged (see ``rerere.autoUpdate``).
1930 However, even with auto staging, ``git rebase`` still stops and
1931 requires an explicit ``git rebase --continue`` to keep going.
1933 In the case where ``git rebase -m`` is being used to flatten history
1934 (such as after a ``tg export --collapse`` prior to a
1935 ``git format-patch``), there's a good chance all conflicts have already
1936 been resolved during normal merge maintenance operations so there's no
1937 reason ``git rebase`` could not automatically continue, but there's no
1938 option to make it do so.
1940 The ``tg rebase`` command provides a ``git rebase --auto-continue``
1943 All the same rebase options can be used (they are simply passed through
1944 to Git unchanged). However, the ``rerere.autoUpdate`` option is
1945 automatically temporarily enabled while running ``git rebase`` and
1946 should ``git rebase`` stop asking one to resolve and continue, but all
1947 conflicts have already been resolved and staged using rerere
1948 information, then ``git rebase --continue`` will be automatically run.
1952 Provides the ability to revert one or more TopGit branches and their
1953 dependencies to a previous state contained within a tag created using
1954 the ``tg tag`` command. In addition to the actual revert mode
1955 operation a list mode operation is also provided to examine a tag's ref
1958 The default mode (``-l`` or ``--list``) shows the state of one or more
1959 of the refs/branches stored in the tag data. When no refs are given on
1960 the command line, all refs in the tag data are shown. With the special
1961 ref name ``--heads`` then the indepedent heads contained in the tag
1962 data are shown. The ``--deps`` option shows the specified refs and all
1963 of their dependencies in a single list with no duplicates. The
1964 ``--rdeps`` option shows a display similar to ``tg summary --rdeps``
1965 for each ref or all TopGit heads if no ref is given on the command
1966 line. The standard ``--no-short``, ``--short=n`` etc. options may be
1967 used to override the default ``--short`` output. With ``--hash`` (or
1968 ``--hash-only``) show only the hash in ``--list`` mode in which case
1969 the default is ``--no-short``. The ``--hash`` option can be used much
1970 like the ``git rev-parse --verify`` command to extract a specific hash
1971 value out of a TopGit tag.
1973 Note that unlike `tg summary`_, here ``--heads`` actually does mean the
1974 ``git merge-base --independent`` heads of the stored refs from the tag
1975 data. To see only the independent TopGit topic branch heads stored in
1976 the tag data use the ``--topgit-heads`` option instead. The default
1977 for the ``--rdeps`` option is ``--topgit-heads`` but ``--heads`` can
1978 be given explicitly to change that. (Note that ``--heads-independent``
1979 is accepted as an alias for ``--heads`` as well.)
1981 The revert mode has three submodes, dry-run mode (``-n`` or
1982 ``--dry-run``), force mode (``-f`` or ``--force``) and interactive mode
1983 (``-i`` or ``--interactive``). If ``--dry-run`` (or ``-n``) is given
1984 no ref updates will actually be performed but what would have been
1985 updated is shown instead. If ``--interactive`` (or ``-i``) is given
1986 then the editor is invoked on an instruction sheet allowing manual
1987 selection of the refs to be updated before proceeding. Since revert is
1988 potentially a destructive operation, at least one of the submodes must
1989 be specified explicitly. If no refs are listed on the command line
1990 then all refs in the tag data are reverted. Otherwise the listed refs
1991 and all of their dependencies (unless ``--no-deps`` is given) are
1992 reverted. Unless ``--no-stash`` is given a new stash will be created
1993 using ``tg tag --stash`` (except, of course, in dry-run mode) just
1994 before actually performing the updates to facilitate recovery from
1997 Both modes accept fully-qualified (i.e. starts with ``refs/``) ref
1998 names as well as unqualified names (which will be assumed to be located
1999 under ``refs/heads/``). In revert mode a tgish ref will always have
2000 both its ``refs/heads/`` and ``refs/top-bases/`` values included no
2001 matter how it's listed unless ``--no-deps`` is given and the ref is
2002 fully qualified (i.e. starts with ``refs/``) or one or the other of its
2003 values was removed from the instruction sheet in interactive mode. In
2004 list mode a tgish ref will always have both its ``refs/heads/`` and
2005 ``refs/top-bases/`` values included only when using the ``--deps`` or
2006 ``--rdeps`` options.
2008 The ``--tgish-only`` option excludes non-tgish refs (i.e. refs that do
2009 not have a ``refs/heads/<name>``, ``refs/top-bases/<name>`` pair).
2011 The ``--exclude`` option (which can be repeated) excludes specific
2012 refs. If the name given to ``--exclude`` is not fully-qualified (i.e.
2013 starts with ``refs/``) then it will exclude both members of a tgish ref
2016 The ``--quiet`` (or ``-q``) option may be used in revert mode to
2017 suppress non-dry-run ref change status messages.
2019 The special tag name ``--stash`` (as well as with ``@{n}`` suffixes)
2020 can be used to refer to ``refs/tgstash``.
2022 The ``tg revert`` command supports tags of tags that contains TopGit
2023 refs. So, for example, if you do this::
2026 git tag -f -a -m "tag the tag" newtag newtag
2028 Then ``newtag`` will be a tag of a tag containing a ``TOPGIT REFS``
2029 section. ``tg revert`` knows how to dereference the outermost
2030 tag to get to the next (and the next etc.) tag to find the
2031 ``TOPGIT REFS`` section so after the above sequence, the tag ``newtag``
2032 can still be used successfully with ``tg revert``.
2034 NOTE: If HEAD points to a ref that is updated by a revert operation
2035 then NO WARNING whatsoever will be issued, but the index and working
2036 tree will always be left completely untouched (and the reflog for
2037 the pointed-to ref can always be used to find the previous value).
2041 Output the "previous" branch(es) in the patch series containing the
2042 current or named branch. The "previous" branch(es) being one step
2046 -i show dependencies based on index instead of branch
2047 -w show dependencies based on working tree instead of branch
2048 -n <steps> take ``<steps>`` "previous" steps (default 1)
2049 --all take as many "previous" steps as possible (aka ``-a``)
2050 --verbose show containing series name(s) (aka ``-v``)
2052 The ``-n`` option may also be given as ``--count`` or ``--count=<n>``.
2054 To list all dependencies of a branch see the ``--deps`` option of
2055 the `tg info`_ command.
2057 See also NAVIGATION_ for full details on "previous" steps.
2061 Output tne "next" branch(es) in the patch series containing the current
2062 or named branch. The "next" branch(es) being one step away by default.
2065 -i show dependencies based on index instead of branch
2066 -w show dependencies based on working tree instead of branch
2067 -n <steps> take ``<steps>`` "next" steps (default 1)
2068 --all take as many "next" steps as possible (aka ``-a``)
2069 --verbose show containing series name(s) (aka ``-v``)
2071 The ``-n`` option may also be given as ``--count`` or ``--count=<n>``.
2073 To list all dependents of a branch see the ``--dependents`` option of
2074 the `tg info`_ command.
2076 See also NAVIGATION_ for full details on "next" steps.
2080 Transition top-bases from old location to new location.
2082 Beginning with TopGit release 0.19.4, TopGit has the ability to store
2083 the top-bases refs in either the old ``ref/top-bases/...`` location or
2084 the new ``refs/heads/{top-bases}/...`` location. Starting with TopGit
2085 release 0.20.0, the default is the new location.
2087 By storing the top-bases under heads, Git is less likely to complain
2088 when manipulating them, hosting providers are more likely to provide
2089 access to them and Git prevents them from pointing at anything other
2090 than a commit object. All in all a win for everyone.
2092 TopGit attempts to automatically detect whether the new or old location
2093 is being used for the top-bases and just do the right thing. However,
2094 by explicitly setting the config value ``topgit.top-bases`` to either
2095 ``refs`` for the old location or ``heads`` for the new location the
2096 auto-detection can be bypassed. If no top-bases refs are present in
2097 the repository the default prior to TopGit release 0.20.0 is to use the
2098 old location but starting with TopGit release 0.20.0 the default is to
2099 use the new location.
2101 The ``tg migrate-bases`` command may be used to migrate top-bases refs
2102 from the old location to the new location (or, by using the
2103 undocumented ``--reverse`` option, vice versa).
2105 With few exceptions (``tg create -r`` and ``tg revert``), all top-bases
2106 refs (both local *and* remote refs) are expected to be stored in the
2107 same location (either new or old). A repository's current location for
2108 storing top-bases refs may be shown with the ``tg --top-bases`` command.
2116 TopGit stores all the topic branches in the regular ``refs/heads/``
2117 namespace (so we recommend distinguishing them with the ``t/`` prefix).
2118 Apart from that, TopGit also maintains a set of auxiliary refs in
2119 ``refs/top-*``. Currently, only ``refs/top-bases/`` is used, containing the
2120 current *base* of the given topic branch -- this is basically a merge of
2121 all the branches the topic branch depends on; it is updated during ``tg
2122 update`` and then merged to the topic branch, and it is the base of a
2123 patch generated from the topic branch by ``tg patch``.
2125 All the metadata is tracked within the source tree and history of the
2126 topic branch itself, in ``.top*`` files; these files are kept isolated
2127 within the topic branches during TopGit-controlled merges and are of
2128 course omitted during ``tg patch``. The state of these files in base
2129 commits is undefined; look at them only in the topic branches
2130 themselves. Currently, two files are defined:
2133 Contains the description of the topic branch in a
2134 mail-like format, plus the author information, whatever
2135 Cc headers you choose or the post-three-dashes message.
2136 When mailing out your patch, basically only a few extra
2137 mail headers are inserted and then the patch itself is
2138 appended. Thus, as your patches evolve, you can record
2139 nuances like whether the particular patch should have
2140 To-list / Cc-maintainer or vice-versa and similar
2141 nuances, if your project is into that. ``From`` is
2142 prefilled from your current ``GIT_AUTHOR_IDENT``; other
2143 headers can be prefilled from various optional
2144 ``topgit.*`` git config options.
2147 Contains the one-per-line list of branches this branch
2148 depends on, pre-seeded by ``tg create``. A (continuously
2149 updated) merge of these branches will be the *base* of
2152 IMPORTANT: DO NOT EDIT ``.topdeps`` MANUALLY!!! If you do so, you need to
2153 know exactly what you are doing, since this file must stay in sync with
2154 the Git history information, otherwise very bad things will happen.
2156 TopGit also automagically installs a bunch of custom commit-related
2157 hooks that will verify whether you are committing the ``.top*`` files in a
2158 sane state. It will add the hooks to separate files within the ``hooks/``
2159 subdirectory, and merely insert calls to them to the appropriate hooks
2160 and make them executable (but will make sure the original hook's code is
2161 not called if the hook was not executable beforehand).
2163 Another automagically installed piece is a ``.git/info/attributes``
2164 specifier for an ``ours`` merge strategy for the files ``.topmsg`` and
2165 ``.topdeps``, and the (intuitive) ``ours`` merge strategy definition in
2172 There are two remaining issues with accessing topic branches in remote
2175 (i) Referring to remote topic branches from your local repository
2176 (ii) Developing some of the remote topic branches locally
2178 There are two somewhat contradictory design considerations here:
2180 (a) Hacking on multiple independent TopGit remotes in a single
2182 (b) Having a self-contained topic system in local refs space
2184 To us, (a) does not appear to be very convincing, while (b) is quite
2185 desirable for ``git-log topic`` etc. working, and increased conceptual
2188 Thus, we choose to instantiate all the topic branches of given remote
2189 locally; this is performed by ``tg remote --populate``. ``tg update``
2190 will also check if a branch can be updated from its corresponding remote
2191 branch. The logic needs to be somewhat involved if we are to "do the
2192 right thing". First, we update the base, handling the remote branch as
2193 if it was the first dependency; thus, conflict resolutions made in the
2194 remote branch will be carried over to our local base automagically.
2195 Then, the base is merged into the remote branch and the result is merged
2196 to the local branch -- again, to carry over remote conflict resolutions.
2197 In the future, this order might be adjustable on a per-update basis, in
2198 case local changes happen to be diverging more than the remote ones.
2199 (See the details in `The Update Process`_ for more in depth coverage.)
2201 All commands by default refer to the remote that ``tg remote --populate``
2202 was called on the last time (stored in the ``topgit.remote`` git
2203 configuration variable). You can manually run any command with a
2204 different base remote by passing ``-r REMOTE`` *before* the subcommand
2205 name or passing ``-u`` *before* the subcommand to run without one.
2211 Running the TopGit test suite only requires POSIX compatibile utilities (just
2212 a POSIX compatibile ``make`` will do) AND a ``perl`` binary.
2214 It is *not* necessary to install TopGit in order to run the TopGit test suite.
2216 To run the TopGit test suite, simply execute this from the top-level of a
2217 TopGit checkout or expanded release tarball:
2223 Yup, that's it. But you're probably thinking, "Why have a whole section just
2224 to say 'run make test'?" Am I right?
2226 The simple ``make test`` command produces a lot of output and while it is
2227 summarized at the end there's a better way.
2229 Do you have the ``prove`` utility available? You need ``perl`` to run the
2230 tests and ``prove`` comes with ``perl`` so you almost cerainly do.
2232 Try running the tests like so:
2236 make DEFAULT_TEST_TARGET=prove test
2239 (For reference, the default value of ``DEFAULT_TEST_TARGET`` is ``test`` which
2240 can be used to override a setting that's been altered using the instructions
2241 shown later on below.)
2243 If that works (you can interrupt it with ``Ctrl-C``), try this next:
2247 make DEFAULT_TEST_TARGET=prove TESTLIB_PROVE_OPTS="-j 4 --timer" test
2249 If that one works (again, you can interrupt it with ``Ctrl-C``) that may end
2250 up being the keeper for running the tests.
2252 However, if you don't have ``prove`` for some reason even though you do have
2253 ``perl``, there's still an alternative for briefer output. Try this:
2257 make TESTLIB_TEST_OPTS=-q test
2259 Much of the normal testing output will be suppressed and there's still a
2260 summary at the end. If you're stuck with this version but your make supports
2261 parallel operation (the ``-j`` *<n>*) option, then you might try this:
2265 make -j 4 TESTLIB_TEST_OPTS=-q test
2267 If your make *does* support the parallel ``-j`` option but still seems to be
2268 only running one test at a time try it like this instead:
2272 make TESTLIB_MAKE_OPTS="-j 4" TESTLIB_TEST_OPTS=-q test
2274 The difference is that ``make -j 4`` relies on make to properly pass down the
2275 parallel job option all the way down to the sub-make that runs the individual
2276 tests when not using prove. Putting the options in ``TESTLIB_MAKE_OPTS``
2277 passes them directly to that (and only that) particular invocation of make.
2279 The final bit of advice for running the tests is that any of those ``make``
2280 variable settings can be enabled by default in a top-level ``config.mak`` file.
2282 For example, to make the ``prove -j 4 --timer`` (my personal favorite) the
2283 default when running the tests, add these lines (creating the file if it does
2284 not already exist) to the ``config.mak`` file located in the top-level of the
2285 TopGit checkout (or expanded release tarball):
2290 # comments are allowed (if preceded by '#')
2291 # so are blank lines
2293 DEFAULT_TEST_TARGET = prove
2294 TESTLIB_PROVE_OPTS = -j 4 --timer
2295 #TESTLIB_TEST_OPTS = --color # force colorized test output
2297 Now simply doing ``make test`` will use those options by default.
2299 There is copious documentation on the testing library and other options in
2300 the various ``README`` files located in the ``t`` subdirectory. The
2301 ``Makefile.mak`` file in the ``t`` subdirectory contains plenty of comments
2302 about possible makefile variable settings as well.
2309 A familiarity with the terms in the GLOSSARY_ is helpful for understanding the
2310 content of this sections. See also the IMPLEMENTATION_ section.
2315 When a branch is "updated" using the ``tg update`` command the following steps
2318 1) The branch and all of its dependencies (and theirs recursively)
2319 are checked to see which ones are *out-of-date*. See glossary_.
2321 2) Each of the branch's direct dependencies (i.e. they are listed in
2322 the branch's ``.topdeps`` file) which is out of date is updated
2323 before proceeding (yup, this is a recursive process).
2325 3) Each of the branch's direct dependencies (i.e. they are listed in
2326 the branch's ``.topdes`` file) that was updated in the previous
2327 step is now merged into the branch's corresponding base. If a
2328 remote is involved, and the branch's corresponding base does NOT
2329 contain the remote branch's corresponding base that remote base is
2330 also merged into the branch's base at this time as well (it will be
2331 the first item merged into the branch's base).
2333 4) If the branch has a corresponding remote branch and the branch
2334 does not already contain it, it's merged into the branch's base
2335 (which was possibly already updated in step (3) to contain the
2336 remote branch's base but not the remote branch itself) on a detached
2337 HEAD. Yup, this step can be a bit confusing and no, the updated
2338 base from step (3) has not yet been merged into the branch itself
2339 yet either. If there is no remote branch this step does not apply.
2340 Using a detached HEAD allows the remote branch to be merged into the
2341 contents of the base without actually perturbing the base's ref.
2343 5) If there is a remote branch present then use the result of step (4)
2344 otherwise use the branch's base and merge that into the branch
2347 That's it! Simple, right? ;)
2349 Unless the auto stash option has been disabled (see `no undo`_, `tg update`_
2350 and `tg tag`_), a copy of all the old refs values will be stashed away
2351 immediately after step (1) before starting step (2), but only if anything is
2352 actually found to be out-of-date.
2357 The ``tg update`` command regularly performs merges while executing an update
2358 operation. In order to speed things up, it attempts to do in-index merges
2359 where possible. It accomplishes this by using a separate, temporary index
2360 file and the ``git read-tree -m --aggressive`` command possibly assisted by
2361 the ``git merge-index`` and ``git merge-file`` commands. This combination may
2362 be repeated more than once to perform an octopus in-index merge. If this
2363 fails, the files are checked out and a normal ``git merge`` three-way merge is
2364 performed (possily multiple times). If the normal ``git merge`` fails then
2365 user intervention is required to resolve the merge conflict(s) and continue.
2367 Since the ``tg annihilate``, ``tg create`` and ``tg depend add`` commands may
2368 end up running the ``tg update`` machinery behind the scenes to complete their
2369 operation they may also result in any of these merge strategies being used.
2371 In addition to the normal Git merge strategies (if the in-index merging fails),
2372 there are four possible TopGit merge strategies that may be shown. Since they
2373 all involve use of the ``git read-tree -m --aggressive`` command they are all
2374 variations of a "trivial aggressive" merge. The "trivial" part because all of
2375 the merges done by ``git read-tree -m`` are described as "trivial" and the
2376 "aggressive" part because the ``--aggressive`` option is always used.
2378 1) "trivial aggressive"
2379 Only two heads were involved and all merging was completed by
2380 the ``git read-tree -m --aggressive`` command.
2382 2) "trivial aggressive automatic"
2383 Only two heads were involved but after the
2384 ``git read-tree -m --aggressive`` command completed there were
2385 still unresolved items and ``git merge-index`` had to be run
2386 (using the ``tg index-merge-one-file`` driver) which ultimately
2387 ran ``git merge-file`` at least once to perform a simple
2388 automatic three-way merge. Hence the "automatic" description
2389 and the "Auto-merging ..." output line(s).
2391 3) "trivial aggressive octopus"
2392 This is the same as a "trivial aggressive" merge except that
2393 more than two heads were involved and after merging the first
2394 two heads, the ``git read-tree -m --aggressive`` step was
2395 repeated again on the result for each additional head. All
2396 merging was completed via multiple
2397 ``git read-tree -m --aggressive`` commands only.
2398 This beast is relatively rare in the wild.
2400 4) "trivial aggressive automatic octopus"
2401 This is very similar to the "trivial aggressive octopus"
2402 except that at least one of the ``git read-tree -m --aggressive``
2403 commands left unresolved items that were handled the same way
2404 as the "trivial aggressive automatic" strategy. This species
2405 is commonly seen in the wild.
2412 Version-controlled file stored at the root level of each
2413 TopGit branch that contains the patch header for a TopGit
2414 branch. See also IMPLEMENTATION_;
2417 Version-controlled file stored at the root level of each
2418 TopGit branch that lists the branch's dependencies one per
2419 line omitting the leading ``refs/heads/`` part. See also
2423 Given two Git commit identifiers (e.g. hashes) C1 and C2,
2424 commit C1 "contains" commit C2 if either they are the same
2425 commit or C2 can be reached from C1 by following one or more
2426 parent links from C1 (perhaps via one or more intermediate
2427 commits along the way). In other words, if C1 contains C2
2428 then C2 is an ancestor of C1 or conversely C1 is a descendant
2429 of C2. Since a TopGit branch name is also the name of a Git
2430 branch (something located under the ``refs/heads`` Git
2431 namespace) and similarly for a TopGit base, they can both be
2432 resolved to a Git commit identifier and then participate in
2433 a branch containment test. An easy mnemonic for this is
2434 "children contain the genes of their parents."
2437 A Basic Regular Expression (BRE) pattern. These are older
2438 style regular expressions but have the advantage that all
2439 characters other than ``\``, ``.``, ``*`` and ``[``
2440 automatically match themselves without need for backslash
2441 quoting (well actually, ``^`` and ``$`` are special at the
2442 beginning and end respectively but otherwise match themselves).
2445 See branch containment.
2448 An Extended Regular Expression (ERE) pattern. These are newer
2449 style regular expressions where all the regular expression
2450 "operator" characters "operate" when NOT preceded by a
2451 backslash and are turned into normal characters with a ``\``.
2452 The backreference atom, however, may not work, but ``?``, ``+``
2453 and ``|`` "operators" do; unlike BREs.
2456 Excellent system for managing a history of changes to one
2457 or more possibly interrelated patches.
2460 A Git branch that has an associated TopGit base. Conceptually
2461 it represents a single patch that is the difference between
2462 the associated TopGit base and the TopGit branch. In other
2463 words ``git diff-tree <TopGit base> <TopGit branch>`` except
2464 that any ``.topdeps`` and/or ``.topmsg`` files are excluded
2465 from the result and the contents of the ``.topmsg`` file from
2466 the TopGit branch is prefixed to the result.
2469 A Git branch whose tree does NOT contain any `.topdeps` or
2470 `.topmsg` entries at the top-level of the tree. It *does*
2471 always have an associated "TopGit base" ref (otherwise it would
2472 not be a "TopGit" branch). See also `BARE BRANCHES`_.
2475 In TopGit context, "bare branch" almost always refers to a
2476 "TopGit bare branch" and should be understood to mean such even
2477 if the leading "TopGit" has been left off.
2480 A Git branch that records the base upon which a TopGit branch's
2481 single conceptual "patch" is built. The name of the Git branch
2482 is derived from the TopGit branch name by stripping off the
2483 leading ``refs/heads/`` and appending the correct prefix where
2484 all TopGit bases are stored (typically either
2485 ``refs/top-bases/`` or ``refs/heads/{top-bases}/`` -- the
2486 prefix for any given repository can be shown by using the
2487 ``tg --top-bases`` command and updated using the
2488 ``tg migrate-bases`` command).
2490 All of a TopGit branch's dependencies are merged into the
2491 corresponding TopGit base during a ``tg update`` of a branch.
2496 TopGit ``[PATCH]`` branch
2497 A TopGit branch whose subject starts with ``[PATCH]``. By
2498 convention these TopGit branches contain a single patch
2499 (equivalent to a single patch file) and have at least one
2500 dependency (i.e. their ``.topdeps`` files are never empty).
2502 TopGit ``[BASE]`` branch
2503 A TopGit branch whose subject starts with ``[BASE]``. By
2504 convention these TopGit branches do not actually contain
2505 any changes and their ``.topdeps`` files are empty. They
2506 are used to control a base dependency that another set of
2507 branches depends on.
2509 TopGit ``[STAGE]`` branch
2510 A TopGit branch whose subject starts with ``[STAGE]``. By
2511 convention these TopGit branches do not actually contain any
2512 changes of their own but do have one or (typically) more
2513 dependencies in their ``.topdeps`` file. These branches are
2514 used to bring together one or (typically) more independent
2515 TopGit ``[PATCH]`` branches into a single branch so that
2516 testing and/or evaluation can be performed on the result.
2519 When merging two (or more) heads that touch the same lines in
2520 the file but in different ways the result is a merge conflict
2521 that requires manual intervention. If a merge conflict occurs
2522 with more than two heads (an octopus merge) it's generally
2523 replaced by multiple three-way merges so that by the time a
2524 user sees a merge conflict needing manual resolution, there
2525 will be only two heads involved.
2528 A Git merge strategy (see the "MERGE STRATEGIES" section of
2529 ``git help merge``) or one of the TopGit `merge strategies`_
2530 used to merge two or more heads.
2532 TopGit merge strategy
2533 See the `Merge Strategies`_ section above for details but
2534 basically these are just in-index merges done using the
2535 ``git read-tree -m --aggressive`` command one or more times
2536 possibily assisted by the ``git merge-index`` and the
2537 ``git merge-file`` commands.
2540 In TopGit context the "next" branch refers to the branch that
2541 corresponds to the next (aka following) patch in an ordered
2542 (aka linearized) list of patches created by exporting the
2543 TopGit branches in patch application order.
2546 A merge involving more than two heads. Note that if there are
2547 less than three independent heads the resulting merge that
2548 started out as an octopus will end up not actually being an
2552 A TopGit branch is considered to be "out-of-date" when ANY of
2553 the following are true:
2555 a) The TopGit branch does NOT contain its
2558 b) The TopGit branch does NOT contain its
2559 corresponding remote branch (there may not be
2560 a remote branch in which case this does not apply)
2562 c) The TopGit branch's base does NOT contain its
2563 corresponding remote branch's base (there may not be
2564 a remote branch in which case this does not apply)
2566 d) Any of the TopGit branches listed in the branch's
2567 ``.topdeps`` file are NOT contained by the branch.
2568 (See "branch containment" above.)
2570 e) Any of the TopGit branches listed in the branch's
2571 ``.topdeps`` file are out-of-date.
2573 Note that if a remote branch is present and is NOT out-of-date
2574 then it will contain its own base and (c) is mostly redundant.
2577 In TopGit context the "previous" (or "prev") branch refers to
2578 the branch that corresponds to the previous (aka preceding)
2579 patch in an ordered (aka linearized) list of patches created by
2580 exporting the TopGit branches in patch application order.
2582 remote TopGit branch
2583 A Git branch with the same branch name as a TopGit branch
2584 but living under ``refs/remotes/<some remote>/`` instead
2585 of just ``refs/heads/``.
2588 The TopGit base branch corresponding to a remote TopGit branch,
2589 which lives under ``refs/remotes/`` somewhere (depending on
2590 what the output of ``tg --top-bases`` is for that remote).
2593 A three-way merge takes a common base and two heads (call them
2594 A and B) and creates a new file that is the common base plus
2595 all of the changes made between the common base and head A
2596 *AND* all of the changes made between the common base and
2597 head B. The technique used to accomplish this is called a
2604 The following references are useful to understand the development of
2605 topgit and its subcommands.
2608 http://public-inbox.org/git/36ca99e90904091034m4d4d31dct78acb333612e678@mail.gmail.com/T/#u
2611 THIRD-PARTY SOFTWARE
2612 --------------------
2614 The following software understands TopGit branches:
2616 * `magit <http://magit.github.io/>`_ -- a git mode for emacs
2618 IMPORTANT: Magit requires its topgit mode to be enabled first, as
2619 described in its documentation, in the "Activating extensions"
2620 subsection. If this is not done, it will not push TopGit branches
2621 correctly, so it's important to enable it even if you plan to mostly use
2622 TopGit from the command line.