| blob | b0d1e0f1fd21cee583328dbd0410c10647b5ce64 |
1 =========================================
2 TopGit -- A different patch queue manager
3 =========================================
6 DESCRIPTION
7 -----------
9 TopGit aims to make handling of large amounts of interdependent topic
10 branches easier. In fact, it is designed especially for the case where
11 you maintain a queue of third-party patches on top of another (perhaps
12 Git-controlled) project and want to easily organize, maintain and submit
13 them -- TopGit achieves that by keeping a separate topic branch for each
14 patch and providing some tools to maintain the branches.
16 See also:
18 :REQUIREMENTS_: Installation requirements
19 :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
30 REQUIREMENTS
31 ------------
33 TopGit is a collection of POSIX shell scripts so a POSIX-compliant shell is
34 required along with some standard POSIX-compliant utilities (e.g. sed, awk,
35 cat, etc.). Git version 1.8.5 or later is also required.
37 To use TopGit with linked working trees (the ``git worktree add`` command),
38 at least Git version 2.5.0 (obviously, since that's when the ``git worktree``
39 command first appeared) is needed in which case linked working trees are then
40 fully supported for use with TopGit.
42 The scripts need to be preprocessed and installed. The Makefile that does
43 this only requires a POSIX make utility (using "`make`" and "`make install`").
44 Running the tests also requires only a POSIX make utility ("`make test`").
46 It is possible to use the DESTDIR functionality to install TopGit to a
47 staging area on one machine, archive that and then unarchive it on another
48 machine to perform an install (provided the build prefix and other options are
49 compatible with the final installed location).
52 INSTALLATION
53 ------------
55 See the file ``INSTALL``.
58 GIT REPOSITORY
59 --------------
61 The TopGit git repository can be found at <http://repo.or.cz/topgit/pro>.
64 RATIONALE
65 ---------
67 Why not use something like StGIT or Guilt or ``rebase -i`` for maintaining
68 your patch queue? The advantage of these tools is their simplicity;
69 they work with patch *series* and defer to the reflog facility for
70 version control of patches (reordering of patches is not
71 version-controlled at all). But there are several disadvantages -- for
72 one, these tools (especially StGIT) do not actually fit well with plain
73 Git at all: it is basically impossible to take advantage of the index
74 effectively when using StGIT. But more importantly, these tools
75 horribly fail in the face of a distributed environment.
77 TopGit has been designed around three main tenets:
79 (i) TopGit is as thin a layer on top of Git as possible. You
80 still maintain your index and commit using Git; TopGit will only
81 automate a few indispensable tasks.
83 (ii) TopGit is anxious about *keeping* your history. It will
84 never rewrite your history, and all metadata is also tracked
85 by Git, smoothly and non-obnoxiously. It is good to have a
86 *single* point when the history is cleaned up, and that is at
87 the point of inclusion in the upstream project; locally, you
88 can see how your patch has evolved and easily return to older
89 versions.
91 (iii) TopGit is specifically designed to work in a
92 distributed environment. You can have several instances of
93 TopGit-aware repositories and smoothly keep them all
94 up-to-date and transfer your changes between them.
96 As mentioned above, the main intended use-case for TopGit is tracking
97 third-party patches, where each patch is effectively a single topic
98 branch. In order to flexibly accommodate even complex scenarios when
99 you track many patches where many are independent but some depend on
100 others, TopGit ignores the ancient Quilt heritage of patch series and
101 instead allows the patches to freely form graphs (DAGs just like Git
102 history itself, only "one level higher"). For now, you have to manually
103 specify which patches the current one depends on, but TopGit might help
104 you with that in the future in a darcs-like fashion.
106 A glossary_ plug: The union (i.e. merge) of patch dependencies is called
107 a *base* of the patch (topic branch).
109 Of course, TopGit is perhaps not the right tool for you:
111 (i) TopGit is not complicated, but StGIT et al. are somewhat
112 simpler, conceptually. If you just want to make a linear
113 purely-local patch queue, deferring to StGIT instead might
114 make more sense.
116 (ii) When using TopGit, your history can get a little hairy
117 over time, especially with all the merges rippling through.
118 ;-)
121 SYNOPSIS
122 --------
124 ::
126 ## Create and evolve a topic branch
127 $ tg create t/gitweb/pathinfo-action
128 tg: Automatically marking dependency on master
129 tg: Creating t/gitweb/pathinfo-action base from master...
130 $ ..hack..
131 $ git commit
132 $ ..fix a mistake..
133 $ git commit
135 ## Create another topic branch on top of the former one
136 $ tg create t/gitweb/nifty-links
137 tg: Automatically marking dependency on t/gitweb/pathinfo-action
138 tg: Creating t/gitweb/nifty-links base from t/gitweb/pathinfo-action...
139 $ ..hack..
140 $ git commit
142 ## Create another topic branch on top of master and submit
143 ## the resulting patch upstream
144 $ tg create t/revlist/author-fixed master
145 tg: Creating t/revlist/author-fixed base from master...
146 $ ..hack..
147 $ git commit
148 $ tg patch -m
149 tg: Sent t/revlist/author-fixed
150 From: pasky@suse.cz
151 To: git@vger.kernel.org
152 Cc: gitster@pobox.com
153 Subject: [PATCH] Fix broken revlist --author when --fixed-string
155 ## Create another topic branch depending on two others non-trivially
156 $ tg create t/whatever t/revlist/author-fixed t/gitweb/nifty-links
157 tg: Creating t/whatever base from t/revlist/author-fixed...
158 tg: Merging t/whatever base with t/gitweb/nifty-links...
159 Merge failed!
160 tg: Please commit merge resolution and call: tg update --continue
161 tg: It is also safe to abort this operation using `git reset --hard`
162 tg: but please remember you are on the base branch now;
163 tg: you will want to switch to a different branch.
164 $ ..resolve..
165 $ git commit
166 $ tg update --continue
167 $ ..hack..
168 $ git commit
170 ## Update a single topic branch and propagate the changes to
171 ## a different one
172 $ git checkout t/gitweb/nifty-links
173 $ ..hack..
174 $ git commit
175 $ git checkout t/whatever
176 $ tg info
177 Topic Branch: t/whatever (1 commit)
178 Subject: [PATCH] Whatever patch
179 Base: 3f47ebc1
180 Depends: t/revlist/author-fixed t/gitweb/nifty-links
181 Needs update from:
182 t/gitweb/nifty-links (1 commit)
183 $ tg update
184 tg: Updating base with t/gitweb/nifty-links changes...
185 Merge failed!
186 tg: Please commit merge resolution and call `tg update --continue`
187 tg: (use `tg status` to see more options)
188 $ ..resolve..
189 $ git commit
190 $ tg update --continue
191 tg: Updating t/whatever against new base...
192 Merge failed!
193 tg: Please commit merge resolution and call `tg update --continue`
194 tg: (use `tg status` to see more options)
195 $ ..resolve..
196 $ git commit
197 $ tg update --continue
199 ## Update a single topic branch and propagate the changes
200 ## further through the dependency chain
201 $ git checkout t/gitweb/pathinfo-action
202 $ ..hack..
203 $ git commit
204 $ git checkout t/whatever
205 $ tg info
206 Topic Branch: t/whatever (1/2 commits)
207 Subject: [PATCH] Whatever patch
208 Base: 0ab2c9b3
209 Depends: t/revlist/author-fixed t/gitweb/nifty-links
210 Needs update from:
211 t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
212 $ tg update
213 tg: Recursing to t/gitweb/nifty-links...
214 [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
215 Merge failed!
216 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
217 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
218 $ ..resolve..
219 $ git commit
220 $ tg update --continue
221 [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base...
222 Merge failed!
223 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
224 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
225 $ ..resolve..
226 $ git commit
227 $ tg update --continue
228 tg: Updating base with t/gitweb/nifty-links changes...
229 tg: Updating t/whatever against new base...
231 ## Clone a TopGit-controlled repository
232 $ git clone URL repo
233 $ cd repo
234 $ tg remote --populate origin
235 ...
236 $ git fetch
237 $ tg update
239 ## Add a TopGit remote to a repository and push to it
240 $ git remote add foo URL
241 $ tg remote foo
242 $ tg push -r foo
244 ## Update from a non-default TopGit remote
245 $ git fetch foo
246 $ tg -r foo summary
247 $ tg -r foo update
250 CONVENTIONS
251 -----------
253 When using TopGit there are several common conventions used when working with
254 TopGit branches. None of them are enforced, they are only suggestions.
256 There are three typical uses for a TopGit branch:
258 1. [PATCH]
259 Normal TopGit branches that represent a single patch. These are known
260 as "patch" TopGit branches.
261 2. [BASE]
262 Empty TopGit branches with no dependencies (an empty ``.topdeps`` file)
263 that represent a base upon which other "normal" TopGit branches depend.
264 These are known as "base" TopGit branches (not to be confused with
265 the refs/top-bases/... refs).
266 3. [STAGE]
267 Empty TopGit branches that serve as a staging area to bring together
268 several other TopGit branches into one place so they can be used/tested
269 all together. These are known as "stage" TopGit branches.
271 An "empty" TopGit branch is one that does not have any changes of its own --
272 it may still have dependencies though ("stage" branches do, "base" branches do
273 not). The ``tg summary`` output shows empty branches with a ``0`` in the
274 listing. Normal "patch" branches that have not been annihilated, "base" and
275 "stage" branches fall into this category. (Annihilated branches are normally
276 omitted from the ``tg summary`` output but can be shown if given explicitly as
277 an argument to the ``tg summary`` command. However, the message line will be
278 incorrect since an annihilated branch has no ``.topmsg`` file of its own.)
280 A "patch" branch name typically starts with ``t/`` whereas "base" and "stage"
281 branch names often do not.
283 A "base" branch is created by using the ``--base`` option of ``tg create``
284 (aka ``--no-deps``) which will automatically suggest a "[BASE]" message prefix
285 rather than "[PATCH]". A "stage" branch is created like a normal patch branch
286 except that the only changes that will ever be made to it are typically to
287 add/remove dependencies. Its subject prefix must be manually changed to
288 "[STAGE]" to reflect its purpose.
290 Since both "base" and "stage" branches typically only have a use for the
291 "Subject:" line from their ``.topmsg`` file, they are quite easily created
292 using the ``--topmsg`` option of ``tg create``.
294 Use of "stage" and "base" branches is completely optional. However, without
295 use of a "stage" branch it will be difficult to test multiple independent
296 patches together all at once. A "base" branch is merely a convenience that
297 provides more explicit control over when a common base for a set of patches
298 gets updated as well as providing a branch that shows in ``tg summary`` output
299 and participates in ``tg remote --populate`` setup.
301 Another advantage to using a "stage" branch is that if a new "patch" branch
302 is created remotely and that new branch is added to a pre-existing "stage"
303 branch on the remote then when the local version of the "stage" branch is
304 updated (after fetching remote updates of course), that new dependency will
305 be merged into the local "stage" branch and the local version of the new remote
306 "patch" branch will be automatically set up at "tg update" time.
308 When using the ``tg tag`` command to create tags that record the current state
309 of one or more TopGit branches, the tags are often created with a name that
310 starts with ``t/``.
312 One last thing, you have enabled ``git rerere`` haven't you?
315 NO UNDO
316 -------
318 Beware, there is no "undo" after running a ``tg update``!
320 Well, that's not entirely correct. Since ``tg update`` never discards commits
321 an "undo" operation is technically feasible provided the old values of all the
322 refs that were affected by the ``tg update`` operation can be determined and
323 then they are simply changed back to their previous values.
325 In practice though, it can be extremely tedious and error prone looking through
326 log information to try and determine what the correct previous values were.
327 Although, since TopGit tries to make sure reflogs are enabled for top-bases
328 refs, using Git's ``@{date}`` notation on all the refs dumped out by a
329 ``tg tag --refs foo``, where "foo" is the branch that was updated whose update
330 needs to be undone, may work.
332 Alternatively, ``tg tag --stash`` can be used prior to the update and then
333 ``tg revert`` used after the update to restore the previous state. This
334 assumes, of course, that you remember to run ``tg tag --stash`` first.
336 The ``tg update`` command understands a ``--stash`` option that tells it to
337 automatically run ``tg tag --stash`` before it starts making changes (if
338 everything is up-to-date it won't run the stash command at all).
340 The ``--stash`` option is the default nowadays when running ``tg update``,
341 add the ``--no-stash`` option to turn it off.
343 There is a preference for this. Setting the config value ``topgit.autostash``
344 to ``false`` will implicitly add the ``--no-stash`` option to any ``tg update``
345 command unless an explicit ``--stash`` option is given.
347 If you are likely to ever want to undo a ``tg update``, setting
348 ``topgit.autostash`` to ``false`` is highly discouraged!
350 Note that the tags saved by ``tg tag --stash`` are stored in the
351 ``refs/tgstash`` ref and its reflog. Unfortunately, while Git is happy to
352 maintain the reflog (once it's been enabled which ``tg tag`` guarantees for
353 ``refs/tgstash``), Git is unable to view an annotated/signed tag's reflog!
354 Instead Git dereferences the tag and shows the wrong thing. Use the
355 ``tg tag -g`` command to view the ``refs/tgstash`` reflog instead.
358 EXTRA SETTINGS
359 --------------
361 TopGit supports various config settings:
363 :ALIASES_: ``topgit.alias.*`` for Git-like command aliases
364 :`tg update`_: ``topgit.autostash`` automatic stash control
365 :`tg create`_: ``topgit.bcc`` default "Bcc:" value for create
366 :`tg create`_: ``topgit.cc`` default "Cc:" value for create
367 :`tg patch`_: ``topgit.from`` "From:" fixups by ``tg patch``
368 :`REMOTE HANDLING`_: ``topgit.remote`` TopGit's default remote
369 :SEQUESTRATION_: ``topgit.sequester`` for sequestration control
370 :`tg update`_: ``topgit.setAutoUpdate`` => ``rerere.autoUpdate``
371 :`tg create`_: ``topgit.subjectPrefix`` "[$prefix PATCH] foo"
372 :`tg create`_: ``topgit.to`` default "To:" value for create
373 :`tg migrate-bases`_: ``topgit.top-bases`` for refs bases location
376 ALIASES
377 -------
379 These work exactly like Git's aliases except they are stored under
380 ``topgit.alias.*`` instead. See the ``git help config`` output under
381 the ``alias.*`` section for details. Do note that while alias nesting is
382 explicitly permitted, a maximum nesting depth of 10 is enforced to help
383 detect accidental aliasing loops from wedging the machine.
385 For example, to create an ``lc`` alias for the ``tg log --compact`` command
386 this command may be used:
388 ::
390 git config --global topgit.alias.lc "log --compact"
392 To make it specific to a particular repository just omit the ``--global``
393 option from the command.
396 NAVIGATION
397 ----------
398 From Previous to Next
399 ~~~~~~~~~~~~~~~~~~~~~
401 For this section, consider the following patch series, to be applied
402 in numerical order as shown:
404 ::
406 0001-F_first-patch.diff
407 0002-G_second-builds-on-F.diff
408 0003-H_third-builds-on-G.diff
409 0004-I_fourth-builds-on-H.diff
410 0005-J_fifth-builds-on-I.diff
411 0006-K_sixth-builds-on-J.diff
412 0007-L_last-patch-needs-K.diff
414 If these were applied to some commit in a Git repository, say commit "A"
415 then a history that looks like this would be created:
417 ::
419 A---F---G---H---I---J---K---L
421 Where the parent of commit "F" is "A" and so on to where the parent of
422 commit "L" is commit "K".
424 If that commit history, from A through L, was then imported into TopGit, one
425 TopGit branch would be created corresponding to each of the commits F
426 through L. This way, for example, if the fourth patch in the series
427 (``0004-I_...diff``) needs work, the TopGit branch corresponding to its patch
428 can be checked out and changes made and then a new version of its patch
429 created (using ``tg patch``) without disturbing the other patches in the series
430 and when ``tg update`` is run, the patches that "follow" the fourth patch
431 (i.e. 5, 6 and 7) will have their corresponding TopGit branches automatically
432 updated to take into account the changes made to the fourth patch.
434 Okay, enough with the review of TopGit systemology
435 ``````````````````````````````````````````````````
437 Imagine then that you are working on the fourth patch (i.e. you have its
438 branch checked out into the working tree) and you want to move to the following
439 patch in the series because you have a nit to pick with it too.
441 If you can't remember the exact name you might have to fumble around or, you
442 can display the name of the following or "next" patch's branch with the, you
443 guessed it, ``tg next`` command. Think of "next" as the "next" logical patch
444 in the series or the next following patch. If the patches are numbered as in
445 the list above, "next" corresponds to the "+1" (plus one) patch.
447 You might have already guessed there's a corresponding ``tg prev`` command
448 which displays the "-1" (minus one) patch. If these commands (``tg next``
449 and ``tg prev``) are not given a branch name to start at they start at the
450 patch corresponding to the current ``HEAD``.
452 Displaying, however, is not so helpful as actually going there. That's where
453 the ``tg checkout`` command comes in. ``tg checkout next`` does a
454 ``git checkout`` of the ``tg next`` branch and, not surprisingly,
455 ``tg checkout prev`` does a ``git checkout`` of the ``tg prev`` branch. For
456 the lazy a single ``n`` or ``p`` can be used with ``tg checkout`` instead of
457 typing out the entire ``next`` or ``prev``. Or, for the anal, ``previous``
458 will also be accepted for ``prev``.
460 Referring to the A...L commit graph shown above, I is the parent of J and,
461 conversely, J is the child of I. (Git only explicitly records the child to
462 parent links, in other words a "child" points to zero or more "parents", but
463 parents are completely clueless about their own children.)
465 For historical reasons, the ``tg checkout`` command accepts ``child`` as a
466 synonym for ``next`` and ``parent`` as a synonym for ``prev``. However, this
467 terminology can be confusing since Git has "parent" links but ``tg checkout``
468 is referring to the TopGit DAG, not Git's. Best to just avoid using ``child``
469 or ``parent`` to talk about navigating the TopGit DAG and reserve them
470 strictly for discussing the Git DAG.
472 There may be more than one
473 ``````````````````````````
475 In a simple linear history as shown above there's always only one "next" or
476 "prev" patch. However, TopGit does not restrict one to only a linear
477 history (although that can make patch exports just a bushel of fun).
479 Suffice it to say that there is always a single linearized ordering for any
480 TopGit patch series since it's always a DAG (Directed Acyclic Graph), but it
481 may not be immediately obvious to the casual observer what that is.
483 The ``tg checkout`` command will display a list to choose from if ``next``
484 or ``prev`` would be ambiguous.
486 Use the ``tg info/checkout --series`` command
487 `````````````````````````````````````````````
489 To see the full, linearized, list of patches with their summary displayed in
490 order from first to last patch in the series, just run the ``tg info --series``
491 command. It takes the name of any patch in the series automatically using
492 ``HEAD`` if none is given. It even provides a nice "YOU ARE HERE" mark in
493 the output list helpful to those who have been absent for a time engaging in
494 otherwise distracting activities and need to be reminded where they are.
496 Using ``tg checkout --series`` can take you there (picking from a list) if
497 you've forgotten the way back to wherever you're supposed to be.
499 Don't get pushy, there's just one more thing
500 ````````````````````````````````````````````
502 For historical reasons, ``tg checkout`` with no arguments whatsoever behaves
503 like ``tg checkout next``. For the same historical reasons, ``tg checkout ..``
504 behaves like ``tg checkout prev`` (think of ``..`` as the "parent" directory
505 and since "parent" means "prev" in this context it will then make sense).
507 Now, for that one more thing. Consider that you have a pristine "upstream"
508 tarball, repository, source dump or otherwise obtained set of unmodified
509 source files that need to be patched. View them like so:
511 ::
513 +-------------------------------+
514 | Unmodified "upstream" source |
515 | files represented with "A" |
516 +-------------------------------+
518 Now, add the first patch, 0001, to them and view the result like so:
520 ::
522 +--------------------------+----+
523 | Patch 0001 represented by "F" |
524 +-------------------------------+
525 | Unmodified "upstream" source |
526 | files represented with "A" |
527 +-------------------------------+
529 Not stopping there, "push" patches 2, 3 and 4 onto the stack as well like so:
531 ::
533 +--------------------------+----+
534 | Patch 0004 represented by "I" |
535 +--------------------------+----+
536 | Patch 0003 represented by "H" |
537 +--------------------------+----+
538 | Patch 0002 represented by "G" |
539 +--------------------------+----+
540 | Patch 0001 represented by "F" |
541 +-------------------------------+
542 | Unmodified "upstream" source |
543 | files represented with "A" |
544 +-------------------------------+
546 In other words, to go to the "next" patch in the series it needs to be "push"ed
547 onto the stack. ``tg checkout`` accepts ``push`` as an alias for ``next``.
549 Similarly to go to the "previous" patch in the series the current one needs
550 to be "pop"ped off the stack. ``tg checkout`` accepts ``pop`` as an alias
551 for ``prev``.
553 Unfortunately for these aliases, in Git terminology a "push" has quite a
554 different meaning and the ``tg push`` command does something quite different
555 from ``tg checkout push``. Then there's the matter of using a single letter
556 abbreviation for the lazy -- ``p`` would mean what exactly?
558 ``tg checkout`` continues to accept the ``push`` and ``pop`` aliases for
559 ``next`` and ``prev`` respectively, but it's best to avoid them since
560 ``push`` has an alternate meaning everywhere else in TopGit and Git and that
561 leaves ``pop`` all alone in the dark.
564 SEQUESTRATION
565 -------------
567 No, this is not a section about budget nonsense. ;)
569 TopGit keeps its metadata in ``.topdeps`` and ``.topmsg`` files. In an effort
570 to facilitate cherry-picking and other Git activities on the patch changes
571 themselves while ignoring the TopGit metadata, TopGit attempts to keep all
572 changes to ``.topdeps`` and ``.topmsg`` files limited to commits that do NOT
573 contain changes to any other files.
575 This is a departure from previous TopGit versions that made no such effort.
577 Primarily this affects ``tg create`` and ``tg import`` (which makes use of
578 ``tg create``) as ``tg create`` will commit the initial versions of
579 ``.topdeps`` and ``.topmsg`` for a new TopGit-controlled branch in their own
580 commit instead of mixing them in with changes to other files.
582 The ``pre-commit`` hook will also attempt to separate out any ``.topdeps`` and
583 ``.topmsg`` changes from commits that include changes to other files.
585 It is possible to defeat these checks without much effort (``pre-commit`` hooks
586 can easily be bypassed, ``tg create`` has a ``--no-commit`` option, many Git
587 commands simply do not run the ``pre-commit`` hook, etc.).
589 If you really, really, really, really want to change the default back to the
590 old behavior of previous TopGit versions where no such sequestration took
591 place, then set the ``topgit.sequester`` config variable explicitly to the
592 value ``false``. But this is not recommended.
595 AMENDING AND REBASING AND UPDATE-REF'ING
596 ----------------------------------------
598 In a word, "don't".
600 It is okay to manually update a top-bases/... ref when a) it has no depedencies
601 (i.e. it was created with the ``tg create`` ``--base`` option) and b) the
602 old top-bases/... ref value can be fast-forwarded to the new top-bases/...
603 value OR the new value contains ALL of the changes in the old value through
604 some other mechanism (perhaps they were cherry-picked or otherwise applied to
605 the new top-bases/... ref). The same rules apply to non-TopGit-controlled
606 dependencies. Use the ``tg update --base <branch> <new-ref>`` command to
607 safely make such an update while making it easy to set the merge commit
608 message at the same time.
610 Ignoring this rule and proceeding anyway with a non-fast-forward update to a
611 top-bases/... ref will result in changes present in the new value being merged
612 into the branch (at ``tg update`` time) as expected (possibly with conflicts),
613 but any changes that were contained in the old version of the top-bases/... ref
614 which have been dropped (i.e. are NOT contained in the new version of the
615 top-bases/... ref) will continue to be present in the branch! To get rid of
616 the dropped commits, one or more "revert" commits will have to be manually
617 applied to the tip of the new top-bases/... value (which will then be merged
618 into the branch at next ``tg update`` time).
620 The only time it's safe to amend, rebase, filter or otherwise rewrite commits
621 contained in a TopGit controlled branch or non-TopGit branch is when those
622 commits are NOT reachable via any other ref!
624 Furthermore, while it is safe to rewrite merge commits (provided they meet the
625 same conditions) the merge commits themselves and the branches they are merging
626 in must be preserved during the rewrite and that can be rather tricky to get
627 right so it's not recommended.
629 For example, if, while working on a TopGit-controlled branch ``foo``, a bad
630 typo is noticed, it's okay to ammend/rebase to fix that provided neither
631 ``tg update`` nor ``tg create`` has already been used to cause some other ref
632 to be able to reach the commit with the typo.
634 If an amend or rerwite is done anyway even though the commit with the typo is
635 reachable from some other ref, the typo won't really be removed. What will
636 happen instead is that the new version without the typo will ultimately be
637 merged into the other ref(s) (at ``tg update`` time) likely causing a conflict
638 that will have to be manually resolved and the commit with the typo will
639 continue to be reachable from those other refs!
641 Instead just make a new commit to fix the typo. The end result will end up
642 being the same but without the merge conflicts.
644 See also the discussion in the `NO UNDO`_ section.
647 SPEED AND CACHING
648 -----------------
650 TopGit needs to check many things to determine whether a TopGit branch is
651 up-to-date or not. This can involve a LOT of git commands for a complex
652 dependency tree. In order to speed things up, TopGit keeps a cache of results
653 in a ``tg-cache`` subdirectory in the ``.git`` directory.
655 Results are tagged with the original hash values used to get that result so
656 that items which have not been changed return their results quickly and items
657 which have been changed compute their new result and cache it for future use.
659 The ``.git/tg-cache`` directory may be removed at any time and the cache will
660 simply be recreated in an on-demand fashion as needed, at some speed penalty,
661 until it's fully rebuilt.
663 To force the cache to be fully pre-loaded, run the ``tg summary`` command
664 without any arguments. Otherwise, normal day-to-day TopGit operations should
665 keep it more-or-less up-to-date.
667 While each TopGit command is running, it uses a temporary subdirectory also
668 located in the ``.git`` directory. These directories are named
669 ``tg-tmp.XXXXXX`` where the ``XXXXXX`` part will be random letters and digits.
671 These temporary directories should always be removed automatically after each
672 TopGit command finishes running. As long as you are not in a subshell as a
673 result of a TopGit command stopping and waiting for a manual merge resolution,
674 it's safe to remove any of these directories that may have somehow accidentally
675 been left behind as a result of some failure that occurred while running a
676 TopGit command (provided, of course, it's not actually being used by a TopGit
677 command currently running in another terminal window or by another user on the
678 same repository).
681 USAGE
682 -----
683 ``tg [global options] <subcommand> [<subcommand option/argument>...]``
685 Global options:
687 ``[-C <dir>]... [-r <remote> | -u] [-c <name>=<val>]... [--no-pager]``
689 -C <dir> Change directory to <dir> before doing anything more
690 -r <remote> Pretend ``topgit.remote`` is set to <remote>
691 -u Pretend ``topgit.remote`` is not set
692 -c <name=val> Pass config option to git, may be repeated
693 --no-pager Disable use of any pager (by both TopGit and Git)
694 --top-bases Show full ``top-bases`` ref prefix and exit
695 --exec-path Show path to subcommand scripts location and exit
696 --help Show brief usage help and exit (aka ``-h``)
698 The ``tg`` tool has several subcommands:
700 :`tg annihilate`_: Mark a TopGit-controlled branch as defunct
701 :`tg base`_: Show base commit for one or more TopGit branches
702 :`tg checkout`_: Shortcut for git checkout with name matching
703 :`tg contains`_: Which TopGit-controlled branch contains the commit
704 :`tg create`_: Create a new TopGit-controlled branch
705 :`tg delete`_: Delete a TopGit-controlled branch cleanly
706 :`tg depend`_: Add a new dependency to a TopGit-controlled branch
707 :`tg export`_: Export TopGit branch patches to files or a branch
708 :`tg files`_: Show files changed by a TopGit branch
709 :`tg help`_: Show TopGit help optionally using a browser
710 :`tg import`_: Import commit(s) to separate TopGit branches
711 :`tg info`_: Show status information about a TopGit branch
712 :`tg log`_: Run git log limiting revisions to a TopGit branch
713 :`tg mail`_: Shortcut for git send-email with ``tg patch`` output
714 :`tg migrate-bases`_: Transition top-bases to new location
715 :`tg next`_: Show branches directly depending on a TopGit branch
716 :`tg patch`_: Generate a patch file for a TopGit branch
717 :`tg prev`_: Show non-annihilated TopGit dependencies for a branch
718 :`tg push`_: Run git push on TopGit branch(es) and depedencies
719 :`tg rebase`_: Auto continue git rebase if rerere resolves conflicts
720 :`tg remote`_: Set up remote for fetching/pushing TopGit branches
721 :`tg revert`_: Revert ref(s) to a state stored in a ``tg tag``
722 :`tg status`_: Show current TopGit status (e.g. in-progress update)
723 :`tg summary`_: Show various information about TopGit branches
724 :`tg tag`_: Create tag that records current TopGit branch state
725 :`tg update`_: Update TopGit branch(es) with respect to dependencies
727 tg help
728 ~~~~~~~
729 Our sophisticated integrated help facility. Mostly duplicates
730 what is below::
732 # to list commands:
733 $ tg help
734 # to get help for a particular command:
735 $ tg help <command>
736 # to get help for a particular command in a browser window:
737 $ tg help -w <command>
738 # to get help on TopGit itself
739 $ tg help tg
740 # to get help on TopGit itself in a browser
741 $ tg help -w tg
743 tg status
744 ~~~~~~~~~
745 Our sophisticated status facility. Similar to Git's status command
746 but shows any in-progress update that's awaiting a merge resolution
747 or any other on-going TopGit activity (such as a branch creation).
749 With a single ``--verbose`` (or ``-v``) option include a short status
750 display for any dirty (but not untracked) files. This also causes all
751 non file status lines to be prefixed with "## ".
753 With two (or more) ``--verbose`` (or ``-v``) options, additionally
754 show full symbolic ref names and unabbreviated hash values.
756 With the ``--exit-code`` option the exit code will be non-zero if any
757 TopGit or Git operation is currently in progress or the working
758 tree is unclean.
760 tg create
761 ~~~~~~~~~
762 Create a new TopGit-controlled topic branch of the given name
763 (required argument) and switch to it. If no dependencies are
764 specified (by extra arguments passed after the first one), the
765 current branch is assumed to be the only dependency.
767 By default ``tg create`` opens an editor on the new ``.topmsg`` file
768 and then commits the new ``.topmsg`` and ``.topdeps`` files
769 automatically with a suitable default commit message.
771 The commit message can be changed with the ``-m`` (or ``--message``) or
772 ``-F`` (or ``--file``) option. The automatic commit can be suppressed
773 by using the ``--no-ccmmit`` option. Running the editor on the new
774 ``.topmsg`` file can be suppressed by using ``-n`` (or ``--no-edit``)
775 (which also suppresses the automatic commit) or by providing an
776 explicit value for the new ``.topmsg`` file using the ``--topmsg`` or
777 ``--topmsg-file`` option. In any case the ``.topmsg`` content will be
778 automatically reformated to have a ``Subject:`` header line if needed.
780 If more than one dependency is listed an automatic ``tg update`` runs
781 after the branch has been created to merge in the additional
782 dependencies and bring the branch up-to-date. This can be suppressed
783 with the ``--no-commit`` option (which also suppresses the initial
784 commit).
786 Previous versions of TopGit behaved as though the ``--no-edit`` option
787 was always given on the command line.
789 The default behavior has been changed to promote a separation between
790 commits that modify ``.topmsg`` and/or ``.topdeps`` and commits that
791 modify other files. This facilitates cleaner cherry picking and other
792 patch maintenance activities.
794 You should edit the patch description (contained in the ``.topmsg``
795 file) as appropriate. It will already contain some prefilled bits.
796 You can set the ``topgit.to``, ``topgit.cc`` and ``topgit.bcc``
797 git configuration variables (see ``man git-config``) in order to
798 have ``tg create`` add these headers with the given default values
799 to ``.topmsg`` before invoking the editor. If the configuration
800 variable ``topgit.subjectPrefix`` is set its value will be inserted
801 *between* the initial ``[`` and the word ``PATCH`` in the subject
802 line (with a space added before the word ``PATCH`` of course).
804 The main task of ``tg create`` is to set up the topic branch base
805 from the dependencies. This may fail due to merge conflicts if more
806 than one dependency is given. In that case, after you commit the
807 conflict resolution, you should call ``tg update --continue`` to
808 finish merging the dependencies into the new topic branch base.
810 With the ``--base`` (aka ``--no-deps``) option at most one dependency
811 may be listed which may be any valid committish (instead of just
812 refs/heads/...) and the newly created TopGit-controlled branch will
813 have an empty ``.topdeps`` file. This may be desirable in order to
814 create a TopGit-controlled branch that has no changes of its own and
815 serves merely to mark the common dependency that all other
816 TopGit-controlled branches in some set of TopGit-controlled branches
817 depend on. A plain, non-TopGit-controlled branch can be used for the
818 same purpose, but the advantage of a TopGit-controlled branch with no
819 dependencies is that it will be pushed with ``tg push``, it will show
820 up in the ``tg summary`` and ``tg info`` output with the subject from
821 its ``.topmsg`` file thereby documenting what it's for and finally it
822 can be set up with ``tg create -r`` and/or ``tg remote --populate`` to
823 facilitate sharing.
825 For example, ``tg create --base release v2.1`` will create a TopGit-
826 controlled ``release`` branch based off the ``v2.1`` tag that can then
827 be used as a base for creation of other TopGit-controlled branches.
828 Then when the time comes to move the base for an entire set of changes
829 up to ``v2.2`` the command ``tg update --base release v2.2`` can be
830 used followed by ``tg update --all``.
832 Using ``--base`` it's also possible to use ``tg create`` on an
833 unborn branch (omit the dependency name or specify ``HEAD``). The
834 unborn branch itself can be made into the new TopGit branch (rather
835 than being born empty and then having the new TopGit branch based off
836 that) by specifying ``HEAD`` as the new branch's name (which is
837 probably what you normally want to do in this case anyway so you can
838 just run ``tg create --base HEAD`` to accomplish that).
840 In an alternative use case, if ``-r <branch>`` is given instead of a
841 dependency list, the topic branch is created based on the given
842 remote branch. With just ``-r`` the remote branch name is assumed
843 to be the same as the local topic branch being created. Since no
844 new commits are created in this mode (only two refs will be updated)
845 the editor will never be run for this use case. Note that no other
846 options may be combined with ``-r``.
848 The ``--quiet`` (or ``-q``) option suppresses most informational
849 messages.
851 tg delete
852 ~~~~~~~~~
853 Remove a TopGit-controlled topic branch of the given name
854 (required argument). Normally, this command will remove only an
855 empty branch (base == head) without dependents; use ``-f`` to
856 remove a non-empty branch or a branch that is depended upon by
857 another branch.
859 The ``-f`` option is also useful to force removal of a branch's
860 base, if you used ``git branch -D B`` to remove branch B, and then
861 certain TopGit commands complain, because the base of branch B
862 is still there.
864 Normally ``tg delete`` will refuse to delete the current branch.
865 However, giving ``-f`` twice (or more) will force it to do so but it
866 will first detach your HEAD.
868 IMPORTANT: Currently, this command will *NOT* remove the branch
869 from the dependency list in other branches. You need to take
870 care of this *manually*. This is even more complicated in
871 combination with ``-f`` -- in that case, you need to manually
872 unmerge the removed branch's changes from the branches depending
873 on it.
875 The same ``--stash`` and ``--no-stash`` options are accepted with
876 the same exact semantics as for `tg update`_.
878 See also ``tg annihilate``.
880 | TODO: ``-a`` to delete all empty branches, depfix, revert
882 tg annihilate
883 ~~~~~~~~~~~~~
884 Make a commit on the current or given TopGit-controlled topic
885 branch that makes it equal to its base, including the presence or
886 absence of .topmsg and .topdeps. Annihilated branches are not
887 displayed by ``tg summary``, so they effectively get out of your
888 way. However, the branch still exists, and ``tg push`` will
889 push it (except if given the ``-a`` option). This way, you can
890 communicate that the branch is no longer wanted.
892 When annihilating a branch that has dependents (i.e. branches
893 that depend on it), those dependents have the dependencies of
894 the branch being annihilated added to them if they do not already
895 have them as dependencies. Essentially the DAG is repaired to
896 skip over the annihilated branch.
898 Normally, this command will remove only an empty branch
899 (base == head, except for changes to the .top* files); use
900 ``-f`` to annihilate a non-empty branch.
902 After completing the annihilation itself, normally ``tg update``
903 is run on any modified dependents. Use the ``--no-update`` option
904 to suppress running ``tg update``.
906 The same ``--stash`` and ``--no-stash`` options are accepted with
907 the same exact semantics as for `tg update`_.
909 tg depend
910 ~~~~~~~~~
911 Change the dependencies of a TopGit-controlled topic branch.
912 This should have several subcommands, but only ``add`` is
913 supported right now.
915 The ``add`` subcommand takes an argument naming a topic branch to
916 be added, adds it to ``.topdeps``, performs a commit and then
917 updates your topic branch accordingly. If you want to do other
918 things related to the dependency addition, like adjusting
919 ``.topmsg``, use the option ``--no-commit``. Adding the
920 ``--no-update`` (or ``--no-commit``) option will suppress the
921 ``tg update`` normally performed after committing the change.
923 It is safe to run ``tg depend add`` in a dirty worktree, but the
924 normally performed ``tg update`` will be suppressed in that case
925 (even if neither ``--no-update`` nor ``--no-commit`` is given).
927 You have enabled ``git rerere`` haven't you?
929 | TODO: Subcommand for removing dependencies, obviously
931 tg files
932 ~~~~~~~~
933 List files changed by the current or specified topic branch.
935 Options:
936 -i list files based on index instead of branch
937 -w list files based on working tree instead of branch
939 tg info
940 ~~~~~~~
941 Show summary information about the current or specified topic
942 branch.
944 Numbers in parenthesis after a branch name such as "(11/3 commits)"
945 indicate how many commits on the branch (11) and how many of those
946 are non-merge commits (3).
948 With ``--verbose`` (or ``-v``) include a list of dependents (i.e. other
949 branches that depend on this one). Another ``--verbose`` annotates
950 them with "[needs merge]" if the current tip of branch for which info
951 is being shown has not yet been merged into the base of the dependent.
953 Alternatively, if ``--heads`` is used then which of the independent
954 TopGit branch heads (as output by ``tg summary --topgit-heads``)
955 logically contains the specified commit (which may be any committish --
956 defaults to ``HEAD`` if not given). Zero or more results will be
957 output. Note that "logically" means with regard to the TopGit
958 dependency relationships as established by the ``.topdeps`` file(s).
959 It's the answer that would be given when all the TopGit branches are
960 up-to-date (even though they need not be to use this option) and the
961 ``git branch --contains`` command is run and the output then filtered
962 to only those branches that appear in ``tg summary --topgit-heads``.
963 This computation may require several seconds on complex repositories.
965 If ``--leaves`` is used then the unique list of leaves of the current
966 or specified topic branch is shown as one fully-qualified ref per line.
967 Duplicates are suppressed and a tag name will be used when appropriate.
968 A "leaf" is any dependency that is either not a TopGit branch or is
969 the base of a non-annihilated TopGit branch with no non-annihilated
970 dependencies.
972 The ``--deps`` option shows non-annihilated TopGit dependencies of the
973 specified branch (default is ``HEAD``).
975 The ``--dependents`` option shows non-annihilated TopGit dependents
976 (i.e. branches that depend on the specified branch). The default
977 branch to operate on is again ``HEAD``.
979 A linearized patch series can only be automatically created for a
980 TopGit topic branch (including its recursive dependencies) when exactly
981 one line is output by ``tg info --leaves <topic-branch>``.
983 With ``--series`` the list of TopGit branches in the order they would
984 be linearized into a patch series is shown along with the description
985 of each branch. If branch name passed to ``tg info`` is not the last
986 branch in the series a marker column will be provided to quickly
987 locate it in the list. This same option can be used with `tg checkout`_.
989 Some patches shown in the list may not actually end up introducing any
990 changes if exported and be therefore end up being omitted. The ``0``
991 indicator in ``tg summary`` output can help to identify some of these.
993 The patches shown in the series in the order they are shown form the
994 basis for the ``tg next`` and ``tg prev`` operations with the first
995 patch shown being considered the first and so on up to the last.
997 tg patch
998 ~~~~~~~~
999 Generate a patch from the current or specified topic branch.
1000 This means that the diff between the topic branch base and head
1001 (latest commit) is shown, appended to the description found in
1002 the ``.topmsg`` file.
1004 The patch is simply dumped to stdout. In the future, ``tg patch``
1005 will be able to automatically send the patches by mail or save
1006 them to files. (TODO)
1008 Options:
1009 -i base patch generation on index instead of branch
1010 -w base patch generation on working tree instead of branch
1011 --binary pass --binary to ``git diff-tree`` to enable generation
1012 of binary patches
1013 --quiet be quiet (aka ``-q``) about missing and unfixed From:
1014 --from make sure patch has a From: line, if not add one using
1015 --from=<a> <a> or Signed-off-by value or ident value; ``git am``
1016 really gets unhappy with patches missing From: lines;
1017 will NOT replace an existing non-empty From: header
1018 --no-from leave all From: lines alone, missing or not (default)
1019 --diff-opt options after the branch name (and an optional ``--``)
1020 are passed directly to ``git diff-tree``
1022 In order to pass a sole explicit ``-w`` through to ``git diff-tree`` it
1023 must be separated from the ``tg`` options by an explicit ``--``.
1024 Or it can be spelled as ``--ignore-all-space`` to distinguuish it from
1025 ``tg``'s ``-w`` option.
1027 If the config variable ``topgit.from`` is set to a boolean it can be
1028 used to enable or disable the ``--from`` option by default. If it's
1029 set to the speical value ``quiet`` the ``--quiet`` option is enabled
1030 and From: lines are left alone by default. Any other non-empty value
1031 is taken as a default ``--from=<value>`` option. The ``--no-from``
1032 option will temporarily disable use of the config value.
1034 If additional non-``tg`` options are passed through to
1035 ``git diff-tree`` (other than ``--binary`` which is fully supported)
1036 the resulting ``tg patch`` output may not be appliable.
1038 tg mail
1039 ~~~~~~~
1040 Send a patch from the current or specified topic branch as
1041 email(s).
1043 Takes the patch given on the command line and emails it out.
1044 Destination addresses such as To, Cc and Bcc are taken from the
1045 patch header.
1047 Since it actually boils down to ``git send-email``, please refer
1048 to the documentation for that for details on how to setup email
1049 for git. You can pass arbitrary options to this command through
1050 the ``-s`` parameter, but you must double-quote everything. The
1051 ``-r`` parameter with a msgid can be used to generate in-reply-to
1052 and reference headers to an earlier mail.
1054 WARNING: be careful when using this command. It easily sends
1055 out several mails. You might want to run::
1057 git config sendemail.confirm always
1059 to let ``git send-email`` ask for confirmation before sending any
1060 mail.
1062 Options:
1063 -i base patch generation on index instead of branch
1064 -w base patch generation on working tree instead of branch
1066 | TODO: ``tg mail patchfile`` to mail an already exported patch
1067 | TODO: mailing patch series
1068 | TODO: specifying additional options and addresses on command line
1070 tg remote
1071 ~~~~~~~~~
1072 Register the given remote as TopGit-controlled. This will create
1073 the namespace for the remote branch bases and teach ``git fetch``
1074 to operate on them. However, from TopGit 0.8 onwards you need to
1075 use ``tg push``, or ``git push --mirror``, for pushing
1076 TopGit-controlled branches.
1078 ``tg remote`` takes an optional remote name argument, and an
1079 optional ``--populate`` switch. Use ``--populate`` for your
1080 origin-style remotes: it will seed the local topic branch system
1081 based on the remote topic branches. ``--populate`` will also make
1082 ``tg remote`` automatically fetch the remote, and ``tg update`` look
1083 at branches of this remote for updates by default.
1085 Using ``--populate`` with a remote name causes the ``topgit.remote``
1086 git configuration variable to be set to the given remote name.
1088 tg summary
1089 ~~~~~~~~~~
1090 Show overview of all TopGit-tracked topic branches and their
1091 up-to-date status. With a branch name limit output to that branch.
1092 Using ``--deps-only`` or ``--rdeps`` changes the default from all
1093 related branches to just the current ``HEAD`` branch but using
1094 ``--all`` as the branch name will show results for all branches
1095 instead of ``HEAD``.
1097 ``>``
1098 marks the current topic branch
1100 ``0``
1101 indicates that it introduces no changes of its own
1103 ``l``/``r``
1104 indicates respectively whether it is local-only
1105 or has a remote mate
1107 ``L``/``R``
1108 indicates respectively if it is ahead or out-of-date
1109 with respect to its remote mate
1111 ``D``
1112 indicates that it is out-of-date with respect to its
1113 dependencies
1115 ``!``
1116 indicates that it has missing dependencies [even if
1117 they are recursive ones]
1119 ``B``
1120 indicates that it is out-of-date with respect to
1121 its base
1123 ``*``
1124 indicates it is ahead of (and needs to be merged into)
1125 at least one of its dependents -- only computed when
1126 showing all branches or using the (possibly implied)
1127 ``--with-deps`` option.
1129 This can take a longish time to accurately determine all the
1130 relevant information about each branch; you can pass ``-t`` (or ``-l``
1131 or ``--list``) to get just a terse list of topic branch names quickly.
1132 Also adding ``--verbose`` (or ``-v``) includes the subjects too.
1134 If no options or arguments are passed, the default is not actually to
1135 show ``--all`` branches (that was the default once upon a time).
1136 Instead, the default is essentially ``--with-deps $(tg info --heads)``
1137 with a fallback to ``--all`` if ``tg info`` doesn't give up any heads.
1138 This usually provides a more intuitive result. Explicitly using
1139 ``--all`` will always show all branches (related or not to ``HEAD``).
1141 Passing ``--heads`` shows independent topic branch names and when
1142 combined with ``--rdeps`` behaves as though ``--rdeps`` were run with
1143 the output of ``--heads``.
1145 The ``--heads-independent`` option works just like ``--heads`` except
1146 that it computes the heads using ``git merge-base --independent``
1147 rather than examining the TopGit ``.topdeps`` relationships. If the
1148 TopGit branches are all up-to-date (as shown in ``tg summary``) then
1149 both ``--heads`` and ``--heads-independent`` should compute the same
1150 list of heads (unless some overlapping TopGit branches have been
1151 manually created). If not all the TopGit branches are up-to-date then
1152 the ``--heads-independent`` results may have extra items in it, but
1153 occasionally that's what's needed; usually it's the wrong answer.
1154 (Note that ``--topgit-heads`` is accepted as an alias for ``--heads``
1155 as well.)
1157 Using ``--heads-only`` behaves as though the output of ``--heads`` was
1158 passed as the list of branches along with ``--without-deps``.
1160 Alternatively, you can pass ``--graphviz`` to get a dot-suitable output
1161 for drawing a dependency graph between the topic branches.
1163 You can also use the ``--sort`` option to sort the branches using
1164 a topological sort. This is especially useful if each
1165 TopGit-tracked topic branch depends on a single parent branch,
1166 since it will then print the branches in the dependency order.
1167 In more complex scenarios, a text graph view would be much more
1168 useful, but that has not yet been implemented.
1170 The ``--deps`` option outputs dependency information between
1171 branches in a machine-readable format. Feed this to ``tsort`` to
1172 get the output from --sort.
1174 The ``--deps-only`` option outputs a sorted list of the unique branch
1175 names given on the command line plus all of their recursive
1176 dependencies (subject to ``--exclude`` of course). When
1177 ``--deps-only`` is given the default is to just display information for
1178 ``HEAD``, but that can be changed by using ``--all`` as the branch
1179 name. Each branch name will appear only once in the output no matter
1180 how many times it's visited while tracing the dependency graph or how
1181 many branch names are given on the command line to process.
1183 The ``--rdeps`` option outputs dependency information in an indented
1184 text format that clearly shows all the dependencies and their
1185 relationships to one another. When ``--rdeps`` is given the default is
1186 to just display information for ``HEAD``, but that can be changed by
1187 using ``--all`` as the branch name or by adding the ``--heads`` option.
1188 Note that ``tg summary --rdeps --heads`` can be particularly helpful in
1189 seeing all the TopGit-controlled branches in the repository and their
1190 relationships to one another.
1192 Note that ``--rdeps`` has two flavors. The first (and default) is
1193 ``--rdeps-once`` which only shows the dependencies of a branch when
1194 it's first visited. For example, if D depends on several other
1195 branches perhaps recursively and both branch A and B depend on D, then
1196 whichever of A or B is shown first will show the entire dependency
1197 chain for D underneath it and the other one will just show a line for
1198 D itself. This can make the output a bit more compact without actually
1199 losing any information which is why it's the default. However, using
1200 the ``--rdeps-full`` variant will repeat the full dependency chain
1201 every time it's encountered.
1203 Adding ``--with-deps`` replaces the given list of branches (which will
1204 default to ``HEAD`` if none are given) with the result of running
1205 ``tg summary --deps-only --tgish`` on the list of branches. This can
1206 be helpful in limiting ``tg summary`` output to only the list of given
1207 branches and their dependencies when many TopGit-controlled branches
1208 are present in the repository. When it would be allowed,
1209 ``--with-deps`` is now the default. Use ``--without-deps`` to switch
1210 back to the old behavior.
1212 With ``--exclude branch``, branch can be excluded from the output
1213 meaning it will be skipped and its name will be omitted from any
1214 dependency output. The ``--exclude`` option may be repeated to omit
1215 more than one branch from the output. Limiting the output to a single
1216 branch that has been excluded will result in no output at all.
1218 The ``--tgish-only`` option behaves as though any non-TopGit-controlled
1219 dependencies encountered during processing had been listed after an
1220 ``--exclude`` option.
1222 Note that the branch name can be specified as ``HEAD`` or ``@`` as a
1223 shortcut for the TopGit-controlled branch that ``HEAD`` is a
1224 symbolic ref to. The ``tg summary @`` command can be quite useful.
1226 Options:
1227 -i Use TopGit metadata from the index instead of the branch
1228 -w Use TopGit metadata from the working tree instead of the branch
1230 tg contains
1231 ~~~~~~~~~~~
1232 Search all TopGit-controlled branches (and optionally their remotes)
1233 to find which TopGit-controlled branch contains the specified commit.
1235 This is more than just basic branch containment as provided for by the
1236 ``git branch --contains`` command. While the shown branch name(s)
1237 will, indeed, be one (or more) of those output by the
1238 ``git branch --contains`` command, the result(s) will exclude any
1239 TopGit-controlled branches from the result(s) that have one (or more)
1240 of their TopGit dependencies (either direct or indirect) appearing in
1241 the ``git branch --contains`` output.
1243 Normally the result will be only the one, single TopGit-controlled
1244 branch for which the specified committish appears in the ``tg log``
1245 output for that branch (unless the committish lies outside the
1246 TopGit-controlled portion of the DAG and ``--no-strict`` was used).
1248 Unless ``--annihilated-okay`` (or ``--ann`` or ``--annihilated``) is
1249 used then annihilated branches will be immediately removed from the
1250 ``git branch --contains`` output before doing anything else. This
1251 means a committish that was originally located in a now-annihilated
1252 branch will show up in whatever branch picked up the annihilated
1253 branch's changes (if there is one). This is usually the correct
1254 answer, but occasionally it's not; hence this option. If this option
1255 is used together with ``--verbose`` then annihilated branches will
1256 be shown as "[:annihilated:]".
1258 In other words, if a ``tg patch`` is generated for the found branch
1259 (assuming one was found and a subsequent commit in the same branch
1260 didn't then revert or otherwise back out the change), then that patch
1261 will include the changes introduced by the specified committish
1262 (unless, of course, that committish is outside the TopGit-controlled
1263 portion of the DAG and ``--no-strict`` was given).
1265 This can be very helpful when, for example, a bug is discovered and
1266 then after using ``git bisect`` (or some other tool) to find the
1267 offending commit it's time to commit the fix. But because the
1268 TopGit merging history can be quite complicated and maybe the one
1269 doing the fix wasn't the bug's author (or the author's memory is just
1270 going), it can sometimes be rather tedious to figure out which
1271 TopGit branch the fix belongs in. The ``tg contains`` command can
1272 quickly tell you the answer to that question.
1274 With the ``--remotes`` (or ``-r``) option a TopGit-controlled remote
1275 branch name may be reported as the result but only if there is no
1276 non-remote branch containing the committish (this can only happen
1277 if at least one of the TopGit-controlled local branches are not yet
1278 up-to-date with their remotes).
1280 With the ``--verbose`` option show which TopGit DAG head(s) (one or
1281 more of the TopGit-controlled branch names output by
1282 ``tg summary --heads``) have the result as a dependency (either direct
1283 or indirect). Using this option will noticeably increase running time.
1285 With the default ``--strict`` option, results for which the base of the
1286 TopGit-controlled branch contains the committish will be suppressed.
1287 For example, if the committish was deep-down in the master branch
1288 history somewhere far outside of the TopGit-controlled portion of
1289 the DAG, with ``--no-strict``, whatever TopGit-controlled branch(es)
1290 first picked up history containing that committish will be shown.
1291 While this is a useful result it's usually not the desired result
1292 which is why it's not the default.
1294 To summarize, even with ``--remotes``, remote results are only shown
1295 if there are no non-remote results. Without ``--no-strict`` (because
1296 ``--strict`` is the default) results outside the TopGit-controlled
1297 portion of the DAG are never shown and even with ``--no-strict`` they
1298 will only be shown if there are no ``--strict`` results. Finally,
1299 the TopGit head info shown with ``--verbose`` only ever appears for
1300 local (i.e. not a remote branch) results. Annihilated branches are
1301 never considered possible matches without ``--annihilated-okay``.
1303 tg checkout
1304 ~~~~~~~~~~~
1305 Switch to a topic branch. You can use ``git checkout <branch>``
1306 to get the same effect, but this command helps you navigate
1307 the dependency graph, or allows you to match the topic branch
1308 name using a regular expression, so it can be more convenient.
1310 The ``--branch`` (or ``-b`` or ``--branch=<name>``) option changes
1311 the default starting point from ``HEAD`` to the specified branch.
1313 For the "next" and "previous" commands, the ``<steps>`` value may
1314 be ``--all`` (or ``-a``) to take "As many steps As possible" or
1315 "step ALL the way" or "ALL steps at once" (or make something better
1316 up yourself).
1318 The following subcommands are available:
1320 ``tg checkout next [<steps>]``
1321 Check out a branch that directly
1322 depends on your current branch.
1323 Move ``<steps>`` (default 1) step(s) in
1324 the "next" direction (AKA ``n``).
1326 ``tg checkout prev [<steps>]``
1327 Check out a branch that this branch
1328 directly depends on. Move ``<steps>``
1329 (default 1) step(s) in the "previous"
1330 direction (AKA ``p`` or ``previous``).
1332 ``tg checkout [goto] [--] <pattern>``
1333 Check out a topic branch that
1334 matches ``<pattern>``. ``<pattern>``
1335 is used as a grep ERE pattern to filter
1336 all the topic branches. Both ``goto`` and
1337 ``--`` may be omitted provided ``<pattern>``
1338 is not ``-a``, ``--all``, ``-h``, ``--help``,
1339 ``goto``, ``--``, ``n``, ``next``, ``push``,
1340 ``child``, ``p``, ``prev``, ``previous``,
1341 ``pop``, ``parent`` or ``..``.
1343 ``tg checkout [goto] [--] --series[=<head>]``
1344 Check out a topic branch that belongs to
1345 the current (or ``<head>``) patch series.
1346 A list with descriptions (``tg info --series``)
1347 will be shown to choose from if more than one.
1349 ``tg checkout push [<steps>]``
1350 An alias for ``next``.
1352 ``tg checkout child [<steps>]``
1353 Deprecated alias for ``next``.
1355 ``tg checkout``
1356 Semi-deprecated alias for ``next``.
1358 ``tg checkout pop [<steps>]``
1359 An alias for ``prev``.
1361 ``tg checkout parent [<steps>]``
1362 Deprecated alias for ``prev``.
1364 ``tg checkout .. [<steps>]``
1365 Semi-deprecated alias for ``prev``.
1367 If any of the above commands can find more than one possible
1368 branch to switch to, you will be presented with the matches
1369 and asked to select one of them.
1371 If the ``--ignore-other-worktrees`` (or ``--iow``) option is given and
1372 the current Git version is at least 2.5.0 then the full
1373 ``--ignore-other-worktrees`` option will be passed along to the
1374 ``git checkout`` command when it's run (otherwise the option will be
1375 silently ignored and not passed to Git as it would cause an error).
1377 The ``--force`` (or ``-f``) option, when given, gets passed through to
1378 the ``git checkout`` command.
1380 The ``--merge`` (or ``-m``) option, when given, gets passed through to
1381 the ``git checkout`` command.
1383 The ``--quiet`` (or ``-q``) option, when given, gets passed through to
1384 the ``git checkout`` command.
1386 The ``<pattern>`` of ``tg checkout goto`` is optional. If you don't
1387 supply it, all the available topic branches are listed and you
1388 can select one of them.
1390 Normally, the ``next`` and ``prev`` commands moves one step in
1391 the dependency graph of the topic branches. The ``-a`` option
1392 causes them (and their aliases) to move as far as possible.
1393 That is, ``tg checkout next -a`` moves to a topic branch that
1394 depends (directly or indirectly) on the current branch and
1395 that no other branch depends on. ``tg checkout prev -a``
1396 moves to a topic branch that the current topic branch
1397 depends on (directly or indirectly). If there is more than
1398 one possibility, you will be prompted for your selection.
1400 See also NAVIGATION_.
1402 tg export
1403 ~~~~~~~~~
1404 Export a tidied-up history of the current topic branch and its
1405 dependencies, suitable for feeding upstream. Each topic branch
1406 corresponds to a single commit or patch in the cleaned up
1407 history (corresponding basically exactly to ``tg patch`` output
1408 for the topic branch).
1410 The command has three possible outputs now -- either a Git branch
1411 with the collapsed history, a Git branch with a linearized
1412 history, or a quilt series in new directory.
1414 In the case where you are producing collapsed history in a new
1415 branch, you can use this collapsed structure either for
1416 providing a pull source for upstream, or for further
1417 linearization e.g. for creation of a quilt series using git log::
1419 git log --pretty=email -p --topo-order origin..exported
1421 To better understand the function of ``tg export``, consider this
1422 dependency structure::
1424 origin/master - t/foo/blue - t/foo/red - master
1425 `- t/bar/good <,----------'
1426 `- t/baz ------------'
1428 (where each of the branches may have a hefty history). Then::
1430 master$ tg export for-linus
1432 will create this commit structure on the branch ``for-linus``::
1434 origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
1435 `- t/bar/good <,-------------------'/
1436 `- t/baz ---------------------'
1438 In this mode, ``tg export`` works on the current topic branch, and
1439 can be called either without an option (in that case,
1440 ``--collapse`` is assumed), or with the ``--collapse`` option, and
1441 with one mandatory argument: the name of the branch where the
1442 exported result will be stored.
1444 When using the linearize mode::
1446 master$ tg export --linearize for-linus
1448 you get a linear history respecting the dependencies of your
1449 patches in a new branch ``for-linus``. The result should be more
1450 or less the same as using quilt mode and then reimporting it
1451 into a Git branch. (More or less because the topological order
1452 can usually be extended in more than one way into a total order,
1453 and the two methods may choose different ones.) The result
1454 might be more appropriate for merging upstream, as it contains
1455 fewer merges.
1457 Note that you might get conflicts during linearization because
1458 the patches are reordered to get a linear history. If linearization
1459 would produce conflicts then using ``--quilt`` will also likely result
1460 in conflicts when the exported quilt series is applied. Since the
1461 ``--quilt`` mode simply runs a series of ``tg patch`` commands to
1462 generate the patches in the exported quilt series and those patches
1463 will end up being applied linearly, the same conflicts that would be
1464 produced by the ``--linearize`` option will then occur at that time.
1466 To avoid conflicts produced by ``--linearize`` (or by applying the
1467 ``--quilt`` output), use the default ``--collapse`` mode and then use
1468 ``tg rebase`` (or ``git rebase -m`` directly) on the collapsed branch
1469 (with a suitable <upstream>) followed by ``git format-patch`` on the
1470 rebased result to produce a conflict-free patch set. A suitable
1471 upstream may be determined with the ``tg info --leaves`` command (if
1472 it outputs more than one line, linearization will be problematic).
1474 You have enabled ``git rerere`` haven't you?
1476 When using the quilt mode::
1478 master$ tg export --quilt for-linus
1480 would create the following directory ``for-linus``::
1482 for-linus/t/foo/blue.diff
1483 for-linus/t/foo/red.diff
1484 for-linus/t/bar/good.diff
1485 for-linus/t/baz.diff
1486 for-linus/series:
1487 t/foo/blue.diff -p1
1488 t/bar/good.diff -p1
1489 t/foo/red.diff -p1
1490 t/baz.diff -p1
1492 With ``--quilt``, you can also pass the ``-b`` parameter followed
1493 by a comma-separated explicit list of branches to export, or
1494 the ``--all`` parameter (which can be shortened to ``-a``) to
1495 export them all. The ``--binary`` option enables producing Git
1496 binary patches. These options are currently only supported
1497 with ``--quilt``.
1499 In ``--quilt`` mode the patches are named like the originating
1500 topgit branch. So usually they end up in subdirectories of the
1501 output directory. With the ``--flatten`` option the names are
1502 mangled so that they end up directly in the output dir (slashes
1503 are replaced with underscores). With the ``--strip[=N]`` option
1504 the first ``N`` subdirectories (all if no ``N`` is given) get
1505 stripped off. Names are always ``--strip``'d before being
1506 ``--flatten``'d. With the option ``--numbered`` (which implies
1507 ``--flatten``) the patch names get a number as prefix to allow
1508 getting the order without consulting the series file, which
1509 eases sending out the patches.
1511 | TODO: Make stripping of non-essential headers configurable
1512 | TODO: Make stripping of [PATCH] and other prefixes configurable
1513 | TODO: ``--mbox`` option to export instead as an mbox file
1514 | TODO: support ``--all`` option in other modes of operation
1515 | TODO: For quilt exporting, export the linearized history created in
1516 a temporary branch--this would allow producing conflict-less
1517 series
1519 tg import
1520 ~~~~~~~~~
1521 Import commits within the given revision range into TopGit,
1522 creating one topic branch per commit. The dependencies are set
1523 up to form a linear sequence starting on your current branch --
1524 or a branch specified by the ``-d`` parameter, if present.
1526 The branch names are auto-guessed from the commit messages and
1527 prefixed by ``t/`` by default; use ``-p <prefix>`` to specify an
1528 alternative prefix (even an empty one).
1530 Alternatively, you can use the ``-s NAME`` parameter to specify
1531 the name of the target branch; the command will then take one
1532 more argument describing a *single* commit to import.
1534 tg update
1535 ~~~~~~~~~
1536 Update the current, specified or all topic branches with respect
1537 to changes in the branches they depend on and remote branches.
1538 This is performed in two phases -- first, changes within the
1539 dependencies are merged to the base, then the base is merged
1540 into the topic branch. The output will guide you on what to do
1541 next in case of conflicts.
1543 You have enabled ``git rerere`` haven't you?
1545 The ``--[no-]auto[-update]`` options together with the
1546 ``topgit.setAutoUpdate`` config item control whether or not TopGit
1547 will automatically temporarily set ``rerere.autoUpdate`` to true while
1548 running ``tg update``. The default is true. Note that this does not
1549 enable Git's ``rerere`` feature, it merely makes it automatically stage
1550 any previously resolved conflicts. The ``rerere.enabled`` setting must
1551 still be separately enabled (i.e. set to ``true``) for the ``rerere``
1552 feature to do anything at all.
1554 Using ``--auto[-update]`` makes ``tg update`` always temporarily set
1555 ``rerere.autoUpdate`` to ``true`` while running ``tg update``. The
1556 ``--no-auto[-update]`` option prevents ``tg update`` from changing the
1557 ``rerere.autoUpdate`` setting, but if ``rerere.autoUpdate`` has already
1558 been enabled in a config file, ``tg update`` never disables it even
1559 with ``--no-auto``. If ``topgit.setAutoUpdate`` is unset or set to
1560 ``true`` then ``tg update`` implicitly does ``--auto``, otherwise it
1561 does ``--no-auto``. An explicit command line ``--[no-]auto[-update]``
1562 option causes the ``topgit.setAutoUpdate`` setting to be ignored.
1564 When both ``rerere.enabled`` and ``rerere.autoUpdate`` are set to true
1565 then ``tg update`` will be able to automatically continue an update
1566 whenever ``git rerere`` resolves all the conflicts during a merge.
1567 This can be such a huge time saver. That's why the default is to have
1568 TopGit automatically set ``rerere.autoUpdate`` to true while
1569 ``tg update`` is running (but remember, unless ``rerere.enabled`` has
1570 been set to ``true`` it won't make any difference).
1572 When ``-a`` (or ``--all``) is specified, updates all topic branches
1573 matched by ``<pattern>``'s (see ``git-for-each-ref(1)`` for details),
1574 or all if no ``<pattern>`` is given. Any topic branches with missing
1575 dependencies will be skipped entirely unless ``--skip-missing`` is
1576 specified.
1578 When ``--skip-missing`` is specified, an attempt is made to update topic
1579 branches with missing dependencies by skipping only the dependencies
1580 that are missing. Caveat utilitor.
1582 When ``--stash`` is specified (or the ``topgit.autostash`` config
1583 value is set to ``true``), a ref stash will be automatically created
1584 just before beginning updates if any are needed. The ``--no-stash``
1585 option may be used to disable a ``topgit.autostash=true`` setting.
1586 See the ``tg tag`` ``--stash`` option for details.
1588 After the update, if a single topic branch was specified, it is
1589 left as the current one; if ``-a`` was specified, it returns to
1590 the branch which was current at the beginning.
1592 If your dependencies are not up-to-date, ``tg update`` will first
1593 recurse into them and update them.
1595 If a remote branch update brings in dependencies on branches
1596 that are not yet instantiated locally, you can either bring in
1597 all the new branches from the remote using ``tg remote
1598 --populate``, or only pick out the missing ones using ``tg create
1599 -r`` (``tg summary`` will point out branches with incomplete
1600 dependencies by showing an ``!`` next to them). TopGit will attempt to
1601 instantiate just the missing ones automatically for you, if possible,
1602 when ``tg update`` merges in the new dependencies from the remote.
1604 Using the alternative ``--base`` mode, ``tg update`` will update
1605 the base of a specified ``[BASE]`` branch (which is a branch created
1606 by ``tg create`` using the ``--base`` option) to the specified
1607 committish (the second argument) and then immediately merge that into
1608 the branch itself using the specified message for the merge commit.
1609 If no message is specified on the command line, an editor will open.
1610 Unless ``--force`` is used the new value for the base must contain
1611 the old value (i.e. be a fast-forward update). This is for safety.
1613 This mode makes updates to ``[BASE]`` branches quick and easy.
1615 | TODO: ``tg update -a -c`` to autoremove (clean) up-to-date branches
1617 tg push
1618 ~~~~~~~
1619 If ``-a`` or ``--all`` was specified, pushes all non-annihilated
1620 TopGit-controlled topic branches, to a remote repository.
1621 Otherwise, pushes the specified topic branches -- or the
1622 current branch, if you don't specify which. By default, the
1623 remote gets all the dependencies (both TopGit-controlled and
1624 non-TopGit-controlled) and bases pushed to it too. If
1625 ``--tgish-only`` was specified, only TopGit-controlled
1626 dependencies will be pushed, and if ``--no-deps`` was specified,
1627 no dependencies at all will be pushed.
1629 The ``--dry-run`` and ``--force`` options are passed directly to
1630 ``git push`` if given.
1632 The remote may be specified with the ``-r`` option. If no remote
1633 was specified, the configured default TopGit remote will be
1634 used.
1636 tg base
1637 ~~~~~~~
1638 Prints the base commit of each of the named topic branches, or
1639 the current branch if no branches are named. Prints an error
1640 message and exits with exit code 1 if the named branch is not
1641 a TopGit branch.
1643 tg log
1644 ~~~~~~
1645 Prints the git log of the named topgit branch -- or the current
1646 branch, if you don't specify a name.
1648 This is really just a convenient shortcut for:
1650 ``git log --first-parent --no-merges $(tg base <name>)..<name>``
1652 where ``<name>`` is the name of the TopGit topic branch (or omitted
1653 for the current branch).
1655 However, if ``<name>`` is a ``[BASE]`` branch the ``--no-merges``
1656 option is omitted.
1658 If ``--compact`` is used then ``git log-compact`` will be used instead
1659 of ``git log``. The ``--command=<git-alias>`` option can be used to
1660 replace "log" with any non-whitespace-containing command alias name,
1661 ``--compact`` is just a shortcut for ``--command=log-compact``. The
1662 ``git-log-compact`` tool may be found on its project page located at:
1664 https://mackyle.github.io/git-log-compact
1666 Note that the ``--compact`` or ``--command=`` option must be used
1667 before any ``--`` or ``git log`` options to be recognized.
1669 NOTE: if you have merged changes from a different repository, this
1670 command might not list all interesting commits.
1672 tg tag
1673 ~~~~~~
1674 Creates a TopGit annotated/signed tag or lists the reflog of one.
1676 A TopGit annotated tag records the current state of one or more TopGit
1677 branches and their dependencies and may be used to revert to the tagged
1678 state at any point in the future.
1680 When reflogs are enabled (the default in a non-bare repository) and
1681 combined with the ``--force`` option a single tag name may be used as a
1682 sort of TopGit branch state stash. The special branch name ``--all``
1683 may be used to tag the state of all current TopGit branches to
1684 facilitate this function and has the side-effect of suppressing the
1685 out-of-date check allowing out-of-date branches to be included.
1687 As a special feature, ``--stash`` may be used as the tag name in which
1688 case ``--all`` is implied if no branch name is listed (instead of the
1689 normal default of ``HEAD``), ``--force`` and ``--no-edit`` (use
1690 ``--edit`` to change that) are automatically activated and the tag will
1691 be saved to ``refs/tgstash`` instead of ``refs/tags/<tagname>``.
1692 The ``--stash`` tag name may also be used with the ``-g``/``--reflog``
1693 option.
1695 The mostly undocumented option ``--allow-outdated`` will bypass the
1696 out-of-date check and is implied when ``--stash`` or ``--all`` is used.
1698 A TopGit annotated/signed tag is simply a Git annotated/signed tag with
1699 a "TOPGIT REFS" section appended to the end of the tag message (and
1700 preceding the signature for signed tags). PEM-style begin and end
1701 lines surround one line per ref where the format of each line is
1702 full-hash SP ref-name. A line will be included for each branch given
1703 on the command line and each ref they depend on either directly or
1704 indirectly.
1706 If more than one TopGit branch is given on the command line, a new
1707 commit will be created that has an empty tree and all of the given
1708 TopGit branches as parents and that commit will be tagged. If a single
1709 TopGit branch is given, then it will be tagged. If the ``--tree``
1710 option is used then it will be used instead of an empty tree (a new
1711 commit will be created if necessary to guarantee the specified tree is
1712 what's in the commit the newly created tag refers to). The argument to
1713 the ``--tree`` option may be any valid treeish.
1715 If exactly one of the branches to be tagged is prefixed with a tilde
1716 (``~``) it will be made the first parent of a consolidation commit if
1717 it is not already the sole commit needing to be tagged. If ``--tree``
1718 is NOT used, its tree will also be used instead of the empty tree for
1719 any new consolidation commit if one is created. Note that if
1720 ``--tree`` is given explicitly it's tree is always used but that does
1721 not in any way affect the choice of first parent. Beware that the
1722 ``~`` may need to be quoted to prevent the shell from misinterpreting
1723 it into something else.
1725 All the options for creating a tag serve the same purpose as their Git
1726 equivalents except for two. The ``--refs`` option suppresses tag
1727 creation entirely and emits the "TOPGIT REFS" section that would have
1728 been included with the tag. If the ``--no-edit`` option is given and
1729 no message is supplied (via the ``-m`` or ``-F`` option) then the
1730 default message created by TopGit will be used without running the
1731 editor.
1733 With ``-g`` or ``--reflog`` show the reflog for a tag. With the
1734 ``--reflog-message`` option the message from the reflog is shown.
1735 With the ``--commit-message`` option the first line of the tag's
1736 message (if the object is a tag) or the commit message (if the object
1737 is a commit) falling back to the reflog message for tree and blob
1738 objects is shown. The default is ``--reflog-message`` unless the
1739 ``--stash`` (``refs/tgstash``) is being shown in which case the default
1740 is then ``--commit-message``. Just add either option explicitly to
1741 override the default.
1743 When showing reflogs, non-tag entries are annotated with their type
1744 unless ``--no-type`` is given.
1746 TopGit tags are created with a reflog if core.logallrefupdates is
1747 enabled (the default for non-bare repositories). Unfortunately Git
1748 is incapable of showing an annotated/signed tag's reflog
1749 (using git log -g) as it will first resolve the tag before checking to
1750 see if it has a reflog. Git can, however, show reflogs for lightweight
1751 tags (using git log -g) just fine but that's not helpful here. Use
1752 ``tg tag`` with the ``-g`` or ``--reflog`` option to see the reflog for
1753 an actual tag object. This also works on non-TopGit annotated/signed
1754 tags as well provided they have a reflog.
1756 The number of entries shown may be limited with the ``-n`` option. If
1757 the tagname is omitted then ``--stash`` is assumed.
1759 The ``--delete`` option is a convenience option that runs the
1760 ``git update-ref -d`` command on the specified tag removing it and its
1761 reflog (if it has one).
1763 The ``--clear`` option clears all but the most recent (the ``@{0}``)
1764 reflog entries from the reflog for the specified tag. It's equivalent
1765 to dropping all the higher numbered reflog entries.
1767 The ``--drop`` option drops the specified reflog entry and requires the
1768 given tagname to have an ``@{n}`` suffix where ``n`` is the reflog
1769 entry number to be dropped. This is really just a convenience option
1770 that runs the appropriate ``git reflog delete`` command.
1772 Note that when combined with ``tg revert``, a tag created by ``tg tag``
1773 can be used to transfer TopGit branches. Simply create the tag, push
1774 it somewhere and then have the recipient run ``tg revert`` to recreate
1775 the TopGit branches. This may be helpful in situations where it's not
1776 feasible to push all the refs corresponding to the TopGit-controlled
1777 branches and their top-bases.
1779 tg rebase
1780 ~~~~~~~~~
1781 Provides a ``git rebase`` rerere auto continue function. It may be
1782 used as a drop-in replacement front-end for ``git rebase -m`` that
1783 automatically continues the rebase when ``git rerere`` information is
1784 sufficient to resolve all conflicts.
1786 You have enabled ``git rerere`` haven't you?
1788 If the ``-m`` or ``--merge`` option is not present then ``tg rebase``
1789 will complain and not do anything.
1791 When ``git rerere`` is enabled, previously resolved conflicts are
1792 remembered and can be automatically staged (see ``rerere.autoUpdate``).
1794 However, even with auto staging, ``git rebase`` still stops and
1795 requires an explicit ``git rebase --continue`` to keep going.
1797 In the case where ``git rebase -m`` is being used to flatten history
1798 (such as after a ``tg export --collapse`` prior to a
1799 ``git format-patch``), there's a good chance all conflicts have already
1800 been resolved during normal merge maintenance operations so there's no
1801 reason ``git rebase`` could not automatically continue, but there's no
1802 option to make it do so.
1804 The ``tg rebase`` command provides a ``git rebase --auto-continue``
1805 function.
1807 All the same rebase options can be used (they are simply passed through
1808 to Git unchanged). However, the ``rerere.autoUpdate`` option is
1809 automatically temporarily enabled while running ``git rebase`` and
1810 should ``git rebase`` stop asking one to resolve and continue, but all
1811 conflicts have already been resolved and staged using rerere
1812 information, then ``git rebase --continue`` will be automatically run.
1814 tg revert
1815 ~~~~~~~~~
1816 Provides the ability to revert one or more TopGit branches and their
1817 dependencies to a previous state contained within a tag created using
1818 the ``tg tag`` command. In addition to the actual revert mode
1819 operation a list mode operation is also provided to examine a tag's ref
1820 contents.
1822 The default mode (``-l`` or ``--list``) shows the state of one or more
1823 of the refs/branches stored in the tag data. When no refs are given on
1824 the command line, all refs in the tag data are shown. With the special
1825 ref name ``--heads`` then the indepedent heads contained in the tag
1826 data are shown. The ``--deps`` option shows the specified refs and all
1827 of their dependencies in a single list with no duplicates. The
1828 ``--rdeps`` option shows a display similar to ``tg summary --rdeps``
1829 for each ref or all TopGit heads if no ref is given on the command
1830 line. The standard ``--no-short``, ``--short=n`` etc. options may be
1831 used to override the default ``--short`` output. With ``--hash`` (or
1832 ``--hash-only``) show only the hash in ``--list`` mode in which case
1833 the default is ``--no-short``. The ``--hash`` option can be used much
1834 like the ``git rev-parse --verify`` command to extract a specific hash
1835 value out of a TopGit tag.
1837 Note that unlike `tg summary`_, here ``--heads`` actually does mean the
1838 ``git merge-base --independent`` heads of the stored refs from the tag
1839 data. To see only the independent TopGit topic branch heads stored in
1840 the tag data use the ``--topgit-heads`` option instead. The default
1841 for the ``--rdeps`` option is ``--topgit-heads`` but ``--heads`` can
1842 be given explicitly to change that. (Note that ``--heads-independent``
1843 is accepted as an alias for ``--heads`` as well.)
1845 The revert mode has three submodes, dry-run mode (``-n`` or
1846 ``--dry-run``), force mode (``-f`` or ``--force``) and interactive mode
1847 (``-i`` or ``--interactive``). If ``--dry-run`` (or ``-n``) is given
1848 no ref updates will actually be performed but what would have been
1849 updated is shown instead. If ``--interactive`` (or ``-i``) is given
1850 then the editor is invoked on an instruction sheet allowing manual
1851 selection of the refs to be updated before proceeding. Since revert is
1852 potentially a destructive operation, at least one of the submodes must
1853 be specified explicitly. If no refs are listed on the command line
1854 then all refs in the tag data are reverted. Otherwise the listed refs
1855 and all of their dependencies (unless ``--no-deps`` is given) are
1856 reverted. Unless ``--no-stash`` is given a new stash will be created
1857 using ``tg tag --stash`` (except, of course, in dry-run mode) just
1858 before actually performing the updates to facilitate recovery from
1859 accidents.
1861 Both modes accept fully-qualified (i.e. starts with ``refs/``) ref
1862 names as well as unqualified names (which will be assumed to be located
1863 under ``refs/heads/``). In revert mode a tgish ref will always have
1864 both its ``refs/heads/`` and ``refs/top-bases/`` values included no
1865 matter how it's listed unless ``--no-deps`` is given and the ref is
1866 fully qualified (i.e. starts with ``refs/``) or one or the other of its
1867 values was removed from the instruction sheet in interactive mode. In
1868 list mode a tgish ref will always have both its ``refs/heads/`` and
1869 ``refs/top-bases/`` values included only when using the ``--deps`` or
1870 ``--rdeps`` options.
1872 The ``--tgish-only`` option excludes non-tgish refs (i.e. refs that do
1873 not have a ``refs/heads/<name>``, ``refs/top-bases/<name>`` pair).
1875 The ``--exclude`` option (which can be repeated) excludes specific
1876 refs. If the name given to ``--exclude`` is not fully-qualified (i.e.
1877 starts with ``refs/``) then it will exclude both members of a tgish ref
1878 pair.
1880 The ``--quiet`` (or ``-q``) option may be used in revert mode to
1881 suppress non-dry-run ref change status messages.
1883 The special tag name ``--stash`` (as well as with ``@{n}`` suffixes)
1884 can be used to refer to ``refs/tgstash``.
1886 The ``tg revert`` command supports tags of tags that contains TopGit
1887 refs. So, for example, if you do this::
1889 tg tag newtag --all
1890 git tag -f -a -m "tag the tag" newtag newtag
1892 Then ``newtag`` will be a tag of a tag containing a ``TOPGIT REFS``
1893 section. ``tg revert`` knows how to dereference the outermost
1894 tag to get to the next (and the next etc.) tag to find the
1895 ``TOPGIT REFS`` section so after the above sequence, the tag ``newtag``
1896 can still be used successfully with ``tg revert``.
1898 NOTE: If HEAD points to a ref that is updated by a revert operation
1899 then NO WARNING whatsoever will be issued, but the index and working
1900 tree will always be left completely untouched (and the reflog for
1901 the pointed-to ref can always be used to find the previous value).
1903 tg prev
1904 ~~~~~~~
1905 Output the "previous" branch(es) in the patch series containing the
1906 current or named branch. The "previous" branch(es) being one step
1907 away by default.
1909 Options:
1910 -i show dependencies based on index instead of branch
1911 -w show dependencies based on working tree instead of branch
1912 -n <steps> take ``<steps>`` "previous" steps (default 1)
1913 --all take as many "previous" steps as possible (aka ``-a``)
1914 --verbose show containing series name(s) (aka ``-v``)
1916 The ``-n`` option may also be given as ``--count`` or ``--count=<n>``.
1918 To list all dependencies of a branch see the ``--deps`` option of
1919 the `tg info`_ command.
1921 See also NAVIGATION_ for full details on "previous" steps.
1923 tg next
1924 ~~~~~~~
1925 Output tne "next" branch(es) in the patch series containing the current
1926 or named branch. The "next" branch(es) being one step away by default.
1928 Options:
1929 -i show dependencies based on index instead of branch
1930 -w show dependencies based on working tree instead of branch
1931 -n <steps> take ``<steps>`` "next" steps (default 1)
1932 --all take as many "next" steps as possible (aka ``-a``)
1933 --verbose show containing series name(s) (aka ``-v``)
1935 The ``-n`` option may also be given as ``--count`` or ``--count=<n>``.
1937 To list all dependents of a branch see the ``--dependents`` option of
1938 the `tg info`_ command.
1940 See also NAVIGATION_ for full details on "next" steps.
1942 tg migrate-bases
1943 ~~~~~~~~~~~~~~~~
1944 Transition top-bases from old location to new location.
1946 Beginning with TopGit release 0.19.4, TopGit has the ability to store
1947 the top-bases refs in either the old ``ref/top-bases/...`` location or
1948 the new ``refs/heads/{top-bases}/...`` location. Starting with TopGit
1949 release 0.20.0, the default is the new location.
1951 By storing the top-bases under heads, Git is less likely to complain
1952 when manipulating them, hosting providers are more likely to provide
1953 access to them and Git prevents them from pointing at anything other
1954 than a commit object. All in all a win for everyone.
1956 TopGit attempts to automatically detect whether the new or old location
1957 is being used for the top-bases and just do the right thing. However,
1958 by explicitly setting the config value ``topgit.top-bases`` to either
1959 ``refs`` for the old location or ``heads`` for the new location the
1960 auto-detection can be bypassed. If no top-bases refs are present in
1961 the repository the default prior to TopGit release 0.20.0 is to use the
1962 old location but starting with TopGit release 0.20.0 the default is to
1963 use the new location.
1965 The ``tg migrate-bases`` command may be used to migrate top-bases refs
1966 from the old location to the new location (or, by using the
1967 undocumented ``--reverse`` option, vice versa).
1969 With few exceptions (``tg create -r`` and ``tg revert``), all top-bases
1970 refs (both local *and* remote refs) are expected to be stored in the
1971 same location (either new or old). A repository's current location for
1972 storing top-bases refs may be shown with the ``tg --top-bases`` command.
1974 TODO: tg rename
1975 ~~~~~~~~~~~~~~~
1977 IMPLEMENTATION
1978 --------------
1980 TopGit stores all the topic branches in the regular ``refs/heads/``
1981 namespace (so we recommend distinguishing them with the ``t/`` prefix).
1982 Apart from that, TopGit also maintains a set of auxiliary refs in
1983 ``refs/top-*``. Currently, only ``refs/top-bases/`` is used, containing the
1984 current *base* of the given topic branch -- this is basically a merge of
1985 all the branches the topic branch depends on; it is updated during ``tg
1986 update`` and then merged to the topic branch, and it is the base of a
1987 patch generated from the topic branch by ``tg patch``.
1989 All the metadata is tracked within the source tree and history of the
1990 topic branch itself, in ``.top*`` files; these files are kept isolated
1991 within the topic branches during TopGit-controlled merges and are of
1992 course omitted during ``tg patch``. The state of these files in base
1993 commits is undefined; look at them only in the topic branches
1994 themselves. Currently, two files are defined:
1996 ``.topmsg``:
1997 Contains the description of the topic branch in a
1998 mail-like format, plus the author information, whatever
1999 Cc headers you choose or the post-three-dashes message.
2000 When mailing out your patch, basically only a few extra
2001 mail headers are inserted and then the patch itself is
2002 appended. Thus, as your patches evolve, you can record
2003 nuances like whether the particular patch should have
2004 To-list / Cc-maintainer or vice-versa and similar
2005 nuances, if your project is into that. ``From`` is
2006 prefilled from your current ``GIT_AUTHOR_IDENT``; other
2007 headers can be prefilled from various optional
2008 ``topgit.*`` git config options.
2010 ``.topdeps``:
2011 Contains the one-per-line list of branches this branch
2012 depends on, pre-seeded by ``tg create``. A (continuously
2013 updated) merge of these branches will be the *base* of
2014 your topic branch.
2016 IMPORTANT: DO NOT EDIT ``.topdeps`` MANUALLY!!! If you do so, you need to
2017 know exactly what you are doing, since this file must stay in sync with
2018 the Git history information, otherwise very bad things will happen.
2020 TopGit also automagically installs a bunch of custom commit-related
2021 hooks that will verify whether you are committing the ``.top*`` files in a
2022 sane state. It will add the hooks to separate files within the ``hooks/``
2023 subdirectory, and merely insert calls to them to the appropriate hooks
2024 and make them executable (but will make sure the original hook's code is
2025 not called if the hook was not executable beforehand).
2027 Another automagically installed piece is a ``.git/info/attributes``
2028 specifier for an ``ours`` merge strategy for the files ``.topmsg`` and
2029 ``.topdeps``, and the (intuitive) ``ours`` merge strategy definition in
2030 ``.git/config``.
2033 REMOTE HANDLING
2034 ---------------
2036 There are two remaining issues with accessing topic branches in remote
2037 repositories:
2039 (i) Referring to remote topic branches from your local repository
2040 (ii) Developing some of the remote topic branches locally
2042 There are two somewhat contradictory design considerations here:
2044 (a) Hacking on multiple independent TopGit remotes in a single
2045 repository
2046 (b) Having a self-contained topic system in local refs space
2048 To us, (a) does not appear to be very convincing, while (b) is quite
2049 desirable for ``git-log topic`` etc. working, and increased conceptual
2050 simplicity.
2052 Thus, we choose to instantiate all the topic branches of given remote
2053 locally; this is performed by ``tg remote --populate``. ``tg update``
2054 will also check if a branch can be updated from its corresponding remote
2055 branch. The logic needs to be somewhat involved if we are to "do the
2056 right thing". First, we update the base, handling the remote branch as
2057 if it was the first dependency; thus, conflict resolutions made in the
2058 remote branch will be carried over to our local base automagically.
2059 Then, the base is merged into the remote branch and the result is merged
2060 to the local branch -- again, to carry over remote conflict resolutions.
2061 In the future, this order might be adjustable on a per-update basis, in
2062 case local changes happen to be diverging more than the remote ones.
2063 (See the details in `The Update Process`_ for more in depth coverage.)
2065 All commands by default refer to the remote that ``tg remote --populate``
2066 was called on the last time (stored in the ``topgit.remote`` git
2067 configuration variable). You can manually run any command with a
2068 different base remote by passing ``-r REMOTE`` *before* the subcommand
2069 name or passing ``-u`` *before* the subcommand to run without one.
2072 TECHNICAL
2073 ---------
2075 A familiarity with the terms in the GLOSSARY_ is helpful for understanding the
2076 content of this sections. See also the IMPLEMENTATION_ section.
2078 The Update Process
2079 ~~~~~~~~~~~~~~~~~~
2081 When a branch is "updated" using the ``tg update`` command the following steps
2082 are taken:
2084 1) The branch and all of its dependencies (and theirs recursively)
2085 are checked to see which ones are *out-of-date*. See glossary_.
2087 2) Each of the branch's direct dependencies (i.e. they are listed in
2088 the branch's ``.topdeps`` file) which is out of date is updated
2089 before proceeding (yup, this is a recursive process).
2091 3) Each of the branch's direct dependencies (i.e. they are listed in
2092 the branch's ``.topdes`` file) that was updated in the previous
2093 step is now merged into the branch's corresponding base. If a
2094 remote is involved, and the branch's corresponding base does NOT
2095 contain the remote branch's corresponding base that remote base is
2096 also merged into the branch's base at this time as well (it will be
2097 the first item merged into the branch's base).
2099 4) If the branch has a corresponding remote branch and the branch
2100 does not already contain it, it's merged into the branch's base
2101 (which was possibly already updated in step (3) to contain the
2102 remote branch's base but not the remote branch itself) on a detached
2103 HEAD. Yup, this step can be a bit confusing and no, the updated
2104 base from step (3) has not yet been merged into the branch itself
2105 yet either. If there is no remote branch this step does not apply.
2106 Using a detached HEAD allows the remote branch to be merged into the
2107 contents of the base without actually perturbing the base's ref.
2109 5) If there is a remote branch present then use the result of step (4)
2110 otherwise use the branch's base and merge that into the branch
2111 itself.
2113 That's it! Simple, right? ;)
2115 Unless the auto stash option has been disabled (see `no undo`_, `tg update`_
2116 and `tg tag`_), a copy of all the old refs values will be stashed away
2117 immediately after step (1) before starting step (2), but only if anything is
2118 actually found to be out-of-date.
2120 Merge Strategies
2121 ~~~~~~~~~~~~~~~~
2123 The ``tg update`` command regularly performs merges while executing an update
2124 operation. In order to speed things up, it attempts to do in-index merges
2125 where possible. It accomplishes this by using a separate, temporary index
2126 file and the ``git read-tree -m --aggressive`` command possibly assisted by
2127 the ``git merge-index`` and ``git merge-file`` commands. This combination may
2128 be repeated more than once to perform an octopus in-index merge. If this
2129 fails, the files are checked out and a normal ``git merge`` three-way merge is
2130 performed (possily multiple times). If the normal ``git merge`` fails then
2131 user intervention is required to resolve the merge conflict(s) and continue.
2133 Since the ``tg annihilate``, ``tg create`` and ``tg depend add`` commands may
2134 end up running the ``tg update`` machinery behind the scenes to complete their
2135 operation they may also result in any of these merge strategies being used.
2137 In addition to the normal Git merge strategies (if the in-index merging fails),
2138 there are four possible TopGit merge strategies that may be shown. Since they
2139 all involve use of the ``git read-tree -m --aggressive`` command they are all
2140 variations of a "trivial aggressive" merge. The "trivial" part because all of
2141 the merges done by ``git read-tree -m`` are described as "trivial" and the
2142 "aggressive" part because the ``--aggressive`` option is always used.
2144 1) "trivial aggressive"
2145 Only two heads were involved and all merging was completed by
2146 the ``git read-tree -m --aggressive`` command.
2148 2) "trivial aggressive automatic"
2149 Only two heads were involved but after the
2150 ``git read-tree -m --aggressive`` command completed there were
2151 still unresolved items and ``git merge-index`` had to be run
2152 (using the ``tg index-merge-one-file`` driver) which ultimately
2153 ran ``git merge-file`` at least once to perform a simple
2154 automatic three-way merge. Hence the "automatic" description
2155 and the "Auto-merging ..." output line(s).
2157 3) "trivial aggressive octopus"
2158 This is the same as a "trivial aggressive" merge except that
2159 more than two heads were involved and after merging the first
2160 two heads, the ``git read-tree -m --aggressive`` step was
2161 repeated again on the result for each additional head. All
2162 merging was completed via multiple
2163 ``git read-tree -m --aggressive`` commands only.
2164 This beast is relatively rare in the wild.
2166 4) "trivial aggressive automatic octopus"
2167 This is very similar to the "trivial aggressive octopus"
2168 except that at least one of the ``git read-tree -m --aggressive``
2169 commands left unresolved items that were handled the same way
2170 as the "trivial aggressive automatic" strategy. This species
2171 is commonly seen in the wild.
2174 GLOSSARY
2175 --------
2177 .topmsg
2178 Version-controlled file stored at the root level of each
2179 TopGit branch that contains the patch header for a TopGit
2180 branch. See also IMPLEMENTATION_;
2182 .topdeps
2183 Version-controlled file stored at the root level of each
2184 TopGit branch that lists the branch's dependencies one per
2185 line omitting the leading ``refs/heads/`` part. See also
2186 IMPLEMENTATION_;
2188 branch containment
2189 Given two Git commit identifiers (e.g. hashes) C1 and C2,
2190 commit C1 "contains" commit C2 if either they are the same
2191 commit or C2 can be reached from C1 by following one or more
2192 parent links from C1 (perhaps via one or more intermediate
2193 commits along the way). In other words, if C1 contains C2
2194 then C2 is an ancestor of C1 or conversely C1 is a descendant
2195 of C2. Since a TopGit branch name is also the name of a Git
2196 branch (something located under the ``refs/heads`` Git
2197 namespace) and similarly for a TopGit base, they can both be
2198 resolved to a Git commit identifier and then participate in
2199 a branch containment test. An easy mnemonic for this is
2200 "children contain the genes of their parents."
2202 BRE pattern
2203 A Basic Regular Expression (BRE) pattern. These are older
2204 style regular expressions but have the advantage that all
2205 characters other than ``\``, ``.``, ``*`` and ``[``
2206 automatically match themselves without need for backslash
2207 quoting (well actually, ``^`` and ``$`` are special at the
2208 beginning and end respectively but otherwise match themselves).
2210 contains
2211 See branch containment.
2213 ERE pattern
2214 An Extended Regular Expression (ERE) pattern. These are newer
2215 style regular expressions where all the regular expression
2216 "operator" characters "operate" when NOT preceded by a
2217 backslash and are turned into normal characters with a ``\``.
2218 The backreference atom, however, may not work, but ``?``, ``+``
2219 and ``|`` "operators" do; unlike BREs.
2221 TopGit
2222 Excellent system for managing a history of changes to one
2223 or more possibly interrelated patches.
2225 TopGit branch
2226 A Git branch that has an associated TopGit base. Conceptually
2227 it represents a single patch that is the difference between
2228 the associated TopGit base and the TopGit branch. In other
2229 words ``git diff-tree <TopGit base> <TopGit branch>`` except
2230 that any ``.topdeps`` and/or ``.topmsg`` files are excluded
2231 from the result and the contents of the ``.topmsg`` file from
2232 the TopGit branch is prefixed to the result.
2234 TopGit base
2235 A Git branch that records the base upon which a TopGit branch's
2236 single conceptual "patch" is built. The name of the Git branch
2237 is derived from the TopGit branch name by stripping off the
2238 leading ``refs/heads/`` and appending the correct prefix where
2239 all TopGit bases are stored (typically either
2240 ``refs/top-bases/`` or ``refs/heads/{top-bases}/`` -- the
2241 prefix for any given repository can be shown by using the
2242 ``tg --top-bases`` command and updated using the
2243 ``tg migrate-bases`` command).
2245 All of a TopGit branch's dependencies are merged into the
2246 corresponding TopGit base during a ``tg update`` of a branch.
2248 base
2249 See TopGit base.
2251 TopGit ``[PATCH]`` branch
2252 A TopGit branch whose subject starts with ``[PATCH]``. By
2253 convention these TopGit branches contain a single patch
2254 (equivalent to a single patch file) and have at least one
2255 dependency (i.e. their ``.topdeps`` files are never empty).
2257 TopGit ``[BASE]`` branch
2258 A TopGit branch whose subject starts with ``[BASE]``. By
2259 convention these TopGit branches do not actually contain
2260 any changes and their ``.topdeps`` files are empty. They
2261 are used to control a base dependency that another set of
2262 branches depends on.
2264 TopGit ``[STAGE]`` branch
2265 A TopGit branch whose subject starts with ``[STAGE]``. By
2266 convention these TopGit branches do not actually contain any
2267 changes of their own but do have one or (typically) more
2268 dependencies in their ``.topdeps`` file. These branches are
2269 used to bring together one or (typically) more independent
2270 TopGit ``[PATCH]`` branches into a single branch so that
2271 testing and/or evaluation can be performed on the result.
2273 merge conflict
2274 When merging two (or more) heads that touch the same lines in
2275 the file but in different ways the result is a merge conflict
2276 that requires manual intervention. If a merge conflict occurs
2277 with more than two heads (an octopus merge) it's generally
2278 replaced by multiple three-way merges so that by the time a
2279 user sees a merge conflict needing manual resolution, there
2280 will be only two heads involved.
2282 merge strategy
2283 A Git merge strategy (see the "MERGE STRATEGIES" section of
2284 ``git help merge``) or one of the TopGit `merge strategies`_
2285 used to merge two or more heads.
2287 TopGit merge strategy
2288 See the `Merge Strategies`_ section above for details but
2289 basically these are just in-index merges done using the
2290 ``git read-tree -m --aggressive`` command one or more times
2291 possibily assisted by the ``git merge-index`` and the
2292 ``git merge-file`` commands.
2294 next branch
2295 In TopGit context the "next" branch refers to the branch that
2296 corresponds to the next (aka following) patch in an ordered
2297 (aka linearized) list of patches created by exporting the
2298 TopGit branches in patch application order.
2300 octopus merge
2301 A merge involving more than two heads. Note that if there are
2302 less than three independent heads the resulting merge that
2303 started out as an octopus will end up not actually being an
2304 octopus after all.
2306 out-of-date branch
2307 A TopGit branch is considered to be "out-of-date" when ANY of
2308 the following are true:
2310 a) The TopGit branch does NOT contain its
2311 corresponding base.
2313 b) The TopGit branch does NOT contain its
2314 corresponding remote branch (there may not be
2315 a remote branch in which case this does not apply)
2317 c) The TopGit branch's base does NOT contain its
2318 corresponding remote branch's base (there may not be
2319 a remote branch in which case this does not apply)
2321 d) Any of the TopGit branches listed in the branch's
2322 ``.topdeps`` file are NOT contained by the branch.
2323 (See "branch containment" above.)
2325 e) Any of the TopGit branches listed in the branch's
2326 ``.topdeps`` file are out-of-date.
2328 Note that if a remote branch is present and is NOT out-of-date
2329 then it will contain its own base and (c) is mostly redundant.
2331 previous branch
2332 In TopGit context the "previous" (or "prev") branch refers to
2333 the branch that corresponds to the previous (aka preceding)
2334 patch in an ordered (aka linearized) list of patches created by
2335 exporting the TopGit branches in patch application order.
2337 remote TopGit branch
2338 A Git branch with the same branch name as a TopGit branch
2339 but living under ``refs/remotes/<some remote>/`` instead
2340 of just ``refs/heads/``.
2342 remote TopGit base
2343 The TopGit base branch corresponding to a remote TopGit branch,
2344 which lives under ``refs/remotes/`` somewhere (depending on
2345 what the output of ``tg --top-bases`` is for that remote).
2347 three-way merge
2348 A three-way merge takes a common base and two heads (call them
2349 A and B) and creates a new file that is the common base plus
2350 all of the changes made between the common base and head A
2351 *AND* all of the changes made between the common base and
2352 head B. The technique used to accomplish this is called a
2353 "merge strategy".
2356 REFERENCES
2357 ----------
2359 The following references are useful to understand the development of
2360 topgit and its subcommands.
2362 * tg depend:
2363 http://public-inbox.org/git/36ca99e90904091034m4d4d31dct78acb333612e678@mail.gmail.com/T/#u
2366 THIRD-PARTY SOFTWARE
2367 --------------------
2369 The following software understands TopGit branches:
2371 * `magit <http://magit.github.io/>`_ -- a git mode for emacs
2373 IMPORTANT: Magit requires its topgit mode to be enabled first, as
2374 described in its documentation, in the "Activating extensions"
2375 subsection. If this is not done, it will not push TopGit branches
2376 correctly, so it's important to enable it even if you plan to mostly use
2377 TopGit from the command line.