| blob | 11d269e9352879f0f6f341d1d8ec786cde79c8fb |
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
28 :`TESTING TOPGIT`_: How to run the TopGit test suite
31 REQUIREMENTS
32 ------------
34 TopGit is a collection of POSIX shell scripts so a POSIX-compliant shell is
35 required along with some standard POSIX-compliant utilities (e.g. sed, awk,
36 cat, etc.). Git version 1.8.5 or later is also required.
38 To use TopGit with linked working trees (the ``git worktree add`` command),
39 at least Git version 2.5.0 (obviously, since that's when the ``git worktree``
40 command first appeared) is needed in which case linked working trees are then
41 fully supported for use with TopGit.
43 The scripts need to be preprocessed and installed. The Makefile that does
44 this only requires a POSIX make utility (using "``make``" and "``make install``").
45 Running the tests (see `TESTING TOPGIT`_) also requires only a POSIX make
46 utility ("``make test``") but does require a ``perl`` binary to be available.
48 It is possible to use the DESTDIR functionality to install TopGit to a
49 staging area on one machine, archive that and then unarchive it on another
50 machine to perform an install (provided the build prefix and other options are
51 compatible with the final installed location).
54 INSTALLATION
55 ------------
57 See the file ``INSTALL``.
60 GIT REPOSITORY
61 --------------
63 The TopGit git repository can be found at <http://repo.or.cz/topgit/pro>.
66 RATIONALE
67 ---------
69 Why not use something like StGIT or Guilt or ``rebase -i`` for maintaining
70 your patch queue? The advantage of these tools is their simplicity;
71 they work with patch *series* and defer to the reflog facility for
72 version control of patches (reordering of patches is not
73 version-controlled at all). But there are several disadvantages -- for
74 one, these tools (especially StGIT) do not actually fit well with plain
75 Git at all: it is basically impossible to take advantage of the index
76 effectively when using StGIT. But more importantly, these tools
77 horribly fail in the face of a distributed environment.
79 TopGit has been designed around three main tenets:
81 (i) TopGit is as thin a layer on top of Git as possible. You
82 still maintain your index and commit using Git; TopGit will only
83 automate a few indispensable tasks.
85 (ii) TopGit is anxious about *keeping* your history. It will
86 never rewrite your history, and all metadata is also tracked
87 by Git, smoothly and non-obnoxiously. It is good to have a
88 *single* point when the history is cleaned up, and that is at
89 the point of inclusion in the upstream project; locally, you
90 can see how your patch has evolved and easily return to older
91 versions.
93 (iii) TopGit is specifically designed to work in a
94 distributed environment. You can have several instances of
95 TopGit-aware repositories and smoothly keep them all
96 up-to-date and transfer your changes between them.
98 As mentioned above, the main intended use-case for TopGit is tracking
99 third-party patches, where each patch is effectively a single topic
100 branch. In order to flexibly accommodate even complex scenarios when
101 you track many patches where many are independent but some depend on
102 others, TopGit ignores the ancient Quilt heritage of patch series and
103 instead allows the patches to freely form graphs (DAGs just like Git
104 history itself, only "one level higher"). For now, you have to manually
105 specify which patches the current one depends on, but TopGit might help
106 you with that in the future in a darcs-like fashion.
108 A glossary_ plug: The union (i.e. merge) of patch dependencies is called
109 a *base* of the patch (topic branch).
111 Of course, TopGit is perhaps not the right tool for you:
113 (i) TopGit is not complicated, but StGIT et al. are somewhat
114 simpler, conceptually. If you just want to make a linear
115 purely-local patch queue, deferring to StGIT instead might
116 make more sense.
118 (ii) When using TopGit, your history can get a little hairy
119 over time, especially with all the merges rippling through.
120 ;-)
123 SYNOPSIS
124 --------
126 ::
128 ## Create and evolve a topic branch
129 $ tg create t/gitweb/pathinfo-action
130 tg: Automatically marking dependency on master
131 tg: Creating t/gitweb/pathinfo-action base from master...
132 $ ..hack..
133 $ git commit
134 $ ..fix a mistake..
135 $ git commit
137 ## Create another topic branch on top of the former one
138 $ tg create t/gitweb/nifty-links
139 tg: Automatically marking dependency on t/gitweb/pathinfo-action
140 tg: Creating t/gitweb/nifty-links base from t/gitweb/pathinfo-action...
141 $ ..hack..
142 $ git commit
144 ## Create another topic branch on top of master and submit
145 ## the resulting patch upstream
146 $ tg create t/revlist/author-fixed master
147 tg: Creating t/revlist/author-fixed base from master...
148 $ ..hack..
149 $ git commit
150 $ tg patch -m
151 tg: Sent t/revlist/author-fixed
152 From: pasky@suse.cz
153 To: git@vger.kernel.org
154 Cc: gitster@pobox.com
155 Subject: [PATCH] Fix broken revlist --author when --fixed-string
157 ## Create another topic branch depending on two others non-trivially
158 $ tg create t/whatever t/revlist/author-fixed t/gitweb/nifty-links
159 tg: Creating t/whatever base from t/revlist/author-fixed...
160 tg: Merging t/whatever base with t/gitweb/nifty-links...
161 Merge failed!
162 tg: Please commit merge resolution and call: tg update --continue
163 tg: It is also safe to abort this operation using `git reset --hard`
164 tg: but please remember you are on the base branch now;
165 tg: you will want to switch to a different branch.
166 $ ..resolve..
167 $ git commit
168 $ tg update --continue
169 $ ..hack..
170 $ git commit
172 ## Update a single topic branch and propagate the changes to
173 ## a different one
174 $ git checkout t/gitweb/nifty-links
175 $ ..hack..
176 $ git commit
177 $ git checkout t/whatever
178 $ tg info
179 Topic Branch: t/whatever (1 commit)
180 Subject: [PATCH] Whatever patch
181 Base: 3f47ebc1
182 Depends: t/revlist/author-fixed t/gitweb/nifty-links
183 Needs update from:
184 t/gitweb/nifty-links (1 commit)
185 $ tg update
186 tg: Updating base with t/gitweb/nifty-links changes...
187 Merge failed!
188 tg: Please commit merge resolution and call `tg update --continue`
189 tg: (use `tg status` to see more options)
190 $ ..resolve..
191 $ git commit
192 $ tg update --continue
193 tg: Updating t/whatever against new base...
194 Merge failed!
195 tg: Please commit merge resolution and call `tg update --continue`
196 tg: (use `tg status` to see more options)
197 $ ..resolve..
198 $ git commit
199 $ tg update --continue
201 ## Update a single topic branch and propagate the changes
202 ## further through the dependency chain
203 $ git checkout t/gitweb/pathinfo-action
204 $ ..hack..
205 $ git commit
206 $ git checkout t/whatever
207 $ tg info
208 Topic Branch: t/whatever (1/2 commits)
209 Subject: [PATCH] Whatever patch
210 Base: 0ab2c9b3
211 Depends: t/revlist/author-fixed t/gitweb/nifty-links
212 Needs update from:
213 t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
214 $ tg update
215 tg: Recursing to t/gitweb/nifty-links...
216 [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
217 Merge failed!
218 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
219 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
220 $ ..resolve..
221 $ git commit
222 $ tg update --continue
223 [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base...
224 Merge failed!
225 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
226 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
227 $ ..resolve..
228 $ git commit
229 $ tg update --continue
230 tg: Updating base with t/gitweb/nifty-links changes...
231 tg: Updating t/whatever against new base...
233 ## Clone a TopGit-controlled repository
234 $ git clone URL repo
235 $ cd repo
236 $ tg remote --populate origin
237 ...
238 $ git fetch
239 $ tg update
241 ## Add a TopGit remote to a repository and push to it
242 $ git remote add foo URL
243 $ tg remote foo
244 $ tg push -r foo
246 ## Update from a non-default TopGit remote
247 $ git fetch foo
248 $ tg -r foo summary
249 $ tg -r foo update
252 CONVENTIONS
253 -----------
255 When using TopGit there are several common conventions used when working with
256 TopGit branches. None of them are enforced, they are only suggestions.
258 There are three typical uses for a TopGit branch:
260 1. [PATCH]
261 Normal TopGit branches that represent a single patch. These are known
262 as "patch" TopGit branches.
263 2. [BASE]
264 Empty TopGit branches with no dependencies (an empty ``.topdeps`` file)
265 that represent a base upon which other "normal" TopGit branches depend.
266 These are known as "base" TopGit branches (not to be confused with
267 the refs/top-bases/... refs).
268 3. [STAGE]
269 Empty TopGit branches that serve as a staging area to bring together
270 several other TopGit branches into one place so they can be used/tested
271 all together. These are known as "stage" TopGit branches.
273 An "empty" TopGit branch is one that does not have any changes of its own --
274 it may still have dependencies though ("stage" branches do, "base" branches do
275 not). The ``tg summary`` output shows empty branches with a ``0`` in the
276 listing. Normal "patch" branches that have not been annihilated, "base" and
277 "stage" branches fall into this category. (Annihilated branches are normally
278 omitted from the ``tg summary`` output but can be shown if given explicitly as
279 an argument to the ``tg summary`` command. However, the message line will be
280 incorrect since an annihilated branch has no ``.topmsg`` file of its own.)
282 A "patch" branch name typically starts with ``t/`` whereas "base" and "stage"
283 branch names often do not.
285 A "base" branch is created by using the ``--base`` option of ``tg create``
286 (aka ``--no-deps``) which will automatically suggest a "[BASE]" message prefix
287 rather than "[PATCH]". A "stage" branch is created like a normal patch branch
288 except that the only changes that will ever be made to it are typically to
289 add/remove dependencies. Its subject prefix must be manually changed to
290 "[STAGE]" to reflect its purpose.
292 Since both "base" and "stage" branches typically only have a use for the
293 "Subject:" line from their ``.topmsg`` file, they are quite easily created
294 using the ``--topmsg`` option of ``tg create``.
296 Use of "stage" and "base" branches is completely optional. However, without
297 use of a "stage" branch it will be difficult to test multiple independent
298 patches together all at once. A "base" branch is merely a convenience that
299 provides more explicit control over when a common base for a set of patches
300 gets updated as well as providing a branch that shows in ``tg summary`` output
301 and participates in ``tg remote --populate`` setup.
303 Occasionally the functionality of a "base" branch is needed but it may not
304 be possible to add any `.topdeps` or `.topmsg` files to the desired branch
305 (perhaps it's externally controlled). `BARE BRANCHES`_ can be used in this
306 case, but while TopGit allows them it deliberately does not provide assistance
307 in setting them up.
309 Another advantage to using a "stage" branch is that if a new "patch" branch
310 is created remotely and that new branch is added to a pre-existing "stage"
311 branch on the remote then when the local version of the "stage" branch is
312 updated (after fetching remote updates of course), that new dependency will
313 be merged into the local "stage" branch and the local version of the new remote
314 "patch" branch will be automatically set up at "tg update" time.
316 When using the ``tg tag`` command to create tags that record the current state
317 of one or more TopGit branches, the tags are often created with a name that
318 starts with ``t/``.
320 One last thing, you have enabled ``git rerere`` haven't you?
323 NO UNDO
324 -------
326 Beware, there is no "undo" after running a ``tg update``!
328 Well, that's not entirely correct. Since ``tg update`` never discards commits
329 an "undo" operation is technically feasible provided the old values of all the
330 refs that were affected by the ``tg update`` operation can be determined and
331 then they are simply changed back to their previous values.
333 In practice though, it can be extremely tedious and error prone looking through
334 log information to try and determine what the correct previous values were.
335 Although, since TopGit tries to make sure reflogs are enabled for top-bases
336 refs, using Git's ``@{date}`` notation on all the refs dumped out by a
337 ``tg tag --refs foo``, where "foo" is the branch that was updated whose update
338 needs to be undone, may work.
340 Alternatively, ``tg tag --stash`` can be used prior to the update and then
341 ``tg revert`` used after the update to restore the previous state. This
342 assumes, of course, that you remember to run ``tg tag --stash`` first.
344 The ``tg update`` command understands a ``--stash`` option that tells it to
345 automatically run ``tg tag --stash`` before it starts making changes (if
346 everything is up-to-date it won't run the stash command at all).
348 The ``--stash`` option is the default nowadays when running ``tg update``,
349 add the ``--no-stash`` option to turn it off.
351 There is a preference for this. Setting the config value ``topgit.autostash``
352 to ``false`` will implicitly add the ``--no-stash`` option to any ``tg update``
353 command unless an explicit ``--stash`` option is given.
355 If you are likely to ever want to undo a ``tg update``, setting
356 ``topgit.autostash`` to ``false`` is highly discouraged!
358 Note that the tags saved by ``tg tag --stash`` are stored in the
359 ``refs/tgstash`` ref and its reflog. Unfortunately, while Git is happy to
360 maintain the reflog (once it's been enabled which ``tg tag`` guarantees for
361 ``refs/tgstash``), Git is unable to view an annotated/signed tag's reflog!
362 Instead Git dereferences the tag and shows the wrong thing. Use the
363 ``tg tag -g`` command to view the ``refs/tgstash`` reflog instead.
366 EXTRA SETTINGS
367 --------------
369 TopGit supports various config settings:
371 :`tg create`_: ``format.signoff`` template Signed-off-by line
372 :ALIASES_: ``topgit.alias.*`` for Git-like command aliases
373 :`tg update`_: ``topgit.autostash`` automatic stash control
374 :`tg create`_: ``topgit.bcc`` default "Bcc:" value for create
375 :`tg create`_: ``topgit.cc`` default "Cc:" value for create
376 :`tg patch`_: ``topgit.from`` "From:" fixups by ``tg patch``
377 :`REMOTE HANDLING`_: ``topgit.remote`` TopGit's default remote
378 :SEQUESTRATION_: ``topgit.sequester`` for sequestration control
379 :`tg update`_: ``topgit.setAutoUpdate`` => ``rerere.autoUpdate``
380 :`tg create`_: ``topgit.subjectPrefix`` "[$prefix PATCH] foo"
381 :`tg create`_: ``topgit.to`` default "To:" value for create
382 :`tg migrate-bases`_: ``topgit.top-bases`` for refs bases location
385 ALIASES
386 -------
388 These work exactly like Git's aliases except they are stored under
389 ``topgit.alias.*`` instead. See the ``git help config`` output under
390 the ``alias.*`` section for details. Do note that while alias nesting is
391 explicitly permitted, a maximum nesting depth of 10 is enforced to help
392 detect accidental aliasing loops and keep them from wedging the machine.
394 For example, to create an ``lc`` alias for the ``tg log --compact`` command
395 this command may be used:
397 ::
399 git config --global topgit.alias.lc "log --compact"
401 To make it specific to a particular repository just omit the ``--global``
402 option from the command.
405 NAVIGATION
406 ----------
407 From Previous to Next
408 ~~~~~~~~~~~~~~~~~~~~~
410 For this section, consider the following patch series, to be applied
411 in numerical order as shown:
413 ::
415 0001-F_first-patch.diff
416 0002-G_second-builds-on-F.diff
417 0003-H_third-builds-on-G.diff
418 0004-I_fourth-builds-on-H.diff
419 0005-J_fifth-builds-on-I.diff
420 0006-K_sixth-builds-on-J.diff
421 0007-L_last-patch-needs-K.diff
423 If these were applied to some commit in a Git repository, say commit "A"
424 then a history that looks like this would be created:
426 ::
428 A---F---G---H---I---J---K---L
430 Where the parent of commit "F" is "A" and so on to where the parent of
431 commit "L" is commit "K".
433 If that commit history, from A through L, was then imported into TopGit, one
434 TopGit branch would be created corresponding to each of the commits F
435 through L. This way, for example, if the fourth patch in the series
436 (``0004-I_...diff``) needs work, the TopGit branch corresponding to its patch
437 can be checked out and changes made and then a new version of its patch
438 created (using ``tg patch``) without disturbing the other patches in the series
439 and when ``tg update`` is run, the patches that "follow" the fourth patch
440 (i.e. 5, 6 and 7) will have their corresponding TopGit branches automatically
441 updated to take into account the changes made to the fourth patch.
443 Okay, enough with the review of TopGit systemology
444 ``````````````````````````````````````````````````
446 Imagine then that you are working on the fourth patch (i.e. you have its
447 branch checked out into the working tree) and you want to move to the following
448 patch in the series because you have a nit to pick with it too.
450 If you can't remember the exact name you might have to fumble around or, you
451 can display the name of the following or "next" patch's branch with the, you
452 guessed it, ``tg next`` command. Think of "next" as the "next" logical patch
453 in the series or the next following patch. If the patches are numbered as in
454 the list above, "next" corresponds to the "+1" (plus one) patch.
456 You might have already guessed there's a corresponding ``tg prev`` command
457 which displays the "-1" (minus one) patch. If these commands (``tg next``
458 and ``tg prev``) are not given a branch name to start at they start at the
459 patch corresponding to the current ``HEAD``.
461 Displaying, however, is not so helpful as actually going there. That's where
462 the ``tg checkout`` command comes in. ``tg checkout next`` does a
463 ``git checkout`` of the ``tg next`` branch and, not surprisingly,
464 ``tg checkout prev`` does a ``git checkout`` of the ``tg prev`` branch. For
465 the lazy a single ``n`` or ``p`` can be used with ``tg checkout`` instead of
466 typing out the entire ``next`` or ``prev``. Or, for the anal, ``previous``
467 will also be accepted for ``prev``.
469 Referring to the A...L commit graph shown above, I is the parent of J and,
470 conversely, J is the child of I. (Git only explicitly records the child to
471 parent links, in other words a "child" points to zero or more "parents", but
472 parents are completely clueless about their own children.)
474 For historical reasons, the ``tg checkout`` command accepts ``child`` as a
475 synonym for ``next`` and ``parent`` as a synonym for ``prev``. However, this
476 terminology can be confusing since Git has "parent" links but ``tg checkout``
477 is referring to the TopGit DAG, not Git's. Best to just avoid using ``child``
478 or ``parent`` to talk about navigating the TopGit DAG and reserve them
479 strictly for discussing the Git DAG.
481 There may be more than one
482 ``````````````````````````
484 In a simple linear history as shown above there's always only one "next" or
485 "prev" patch. However, TopGit does not restrict one to only a linear
486 history (although that can make patch exports just a bushel of fun).
488 Suffice it to say that there is always a single linearized ordering for any
489 TopGit patch series since it's always a DAG (Directed Acyclic Graph), but it
490 may not be immediately obvious to the casual observer what that is.
492 The ``tg checkout`` command will display a list to choose from if ``next``
493 or ``prev`` would be ambiguous.
495 Use the ``tg info/checkout --series`` command
496 `````````````````````````````````````````````
498 To see the full, linearized, list of patches with their summary displayed in
499 order from first to last patch in the series, just run the ``tg info --series``
500 command. It takes the name of any patch in the series automatically using
501 ``HEAD`` if none is given. It even provides a nice "YOU ARE HERE" mark in
502 the output list helpful to those who have been absent for a time engaging in
503 otherwise distracting activities and need to be reminded where they are.
505 Using ``tg checkout --series`` can take you there (picking from a list) if
506 you've forgotten the way back to wherever you're supposed to be.
508 Don't get pushy, there's just one more thing
509 ````````````````````````````````````````````
511 For historical reasons, ``tg checkout`` with no arguments whatsoever behaves
512 like ``tg checkout next``. For the same historical reasons, ``tg checkout ..``
513 behaves like ``tg checkout prev`` (think of ``..`` as the "parent" directory
514 and since "parent" means "prev" in this context it will then make sense).
516 Now, for that one more thing. Consider that you have a pristine "upstream"
517 tarball, repository, source dump or otherwise obtained set of unmodified
518 source files that need to be patched. View them like so:
520 ::
522 +-------------------------------+
523 | Unmodified "upstream" source |
524 | files represented with "A" |
525 +-------------------------------+
527 Now, add the first patch, 0001, to them and view the result like so:
529 ::
531 +--------------------------+----+
532 | Patch 0001 represented by "F" |
533 +-------------------------------+
534 | Unmodified "upstream" source |
535 | files represented with "A" |
536 +-------------------------------+
538 Not stopping there, "push" patches 2, 3 and 4 onto the stack as well like so:
540 ::
542 +--------------------------+----+
543 | Patch 0004 represented by "I" |
544 +--------------------------+----+
545 | Patch 0003 represented by "H" |
546 +--------------------------+----+
547 | Patch 0002 represented by "G" |
548 +--------------------------+----+
549 | Patch 0001 represented by "F" |
550 +-------------------------------+
551 | Unmodified "upstream" source |
552 | files represented with "A" |
553 +-------------------------------+
555 In other words, to go to the "next" patch in the series it needs to be "push"ed
556 onto the stack. ``tg checkout`` accepts ``push`` as an alias for ``next``.
558 Similarly to go to the "previous" patch in the series the current one needs
559 to be "pop"ped off the stack. ``tg checkout`` accepts ``pop`` as an alias
560 for ``prev``.
562 Unfortunately for these aliases, in Git terminology a "push" has quite a
563 different meaning and the ``tg push`` command does something quite different
564 from ``tg checkout push``. Then there's the matter of using a single letter
565 abbreviation for the lazy -- ``p`` would mean what exactly?
567 ``tg checkout`` continues to accept the ``push`` and ``pop`` aliases for
568 ``next`` and ``prev`` respectively, but it's best to avoid them since
569 ``push`` has an alternate meaning everywhere else in TopGit and Git and that
570 leaves ``pop`` all alone in the dark.
573 SEQUESTRATION
574 -------------
576 No, this is not a section about budget nonsense. ;)
578 TopGit keeps its metadata in ``.topdeps`` and ``.topmsg`` files. In an effort
579 to facilitate cherry-picking and other Git activities on the patch changes
580 themselves while ignoring the TopGit metadata, TopGit attempts to keep all
581 changes to ``.topdeps`` and ``.topmsg`` files limited to commits that do NOT
582 contain changes to any other files.
584 This is a departure from previous TopGit versions that made no such effort.
586 Primarily this affects ``tg create`` and ``tg import`` (which makes use of
587 ``tg create``) as ``tg create`` will commit the initial versions of
588 ``.topdeps`` and ``.topmsg`` for a new TopGit-controlled branch in their own
589 commit instead of mixing them in with changes to other files.
591 The ``pre-commit`` hook will also attempt to separate out any ``.topdeps`` and
592 ``.topmsg`` changes from commits that include changes to other files.
594 It is possible to defeat these checks without much effort (``pre-commit`` hooks
595 can easily be bypassed, ``tg create`` has a ``--no-commit`` option, many Git
596 commands simply do not run the ``pre-commit`` hook, etc.).
598 If you really, really, really, really want to change the default back to the
599 old behavior of previous TopGit versions where no such sequestration took
600 place, then set the ``topgit.sequester`` config variable explicitly to the
601 value ``false``. But this is not recommended.
604 AMENDING AND REBASING AND UPDATE-REF'ING
605 ----------------------------------------
607 In a word, "don't".
609 It is okay to manually update a top-bases/... ref when a) it has no depedencies
610 (i.e. it was created with the ``tg create`` ``--base`` option) and b) the
611 old top-bases/... ref value can be fast-forwarded to the new top-bases/...
612 value OR the new value contains ALL of the changes in the old value through
613 some other mechanism (perhaps they were cherry-picked or otherwise applied to
614 the new top-bases/... ref). The same rules apply to non-TopGit-controlled
615 dependencies. Use the ``tg update --base <branch> <new-ref>`` command to
616 safely make such an update while making it easy to set the merge commit
617 message at the same time.
619 Ignoring this rule and proceeding anyway with a non-fast-forward update to a
620 top-bases/... ref will result in changes present in the new value being merged
621 into the branch (at ``tg update`` time) as expected (possibly with conflicts),
622 but any changes that were contained in the old version of the top-bases/... ref
623 which have been dropped (i.e. are NOT contained in the new version of the
624 top-bases/... ref) will continue to be present in the branch! To get rid of
625 the dropped commits, one or more "revert" commits will have to be manually
626 applied to the tip of the new top-bases/... value (which will then be merged
627 into the branch at next ``tg update`` time).
629 The only time it's safe to amend, rebase, filter or otherwise rewrite commits
630 contained in a TopGit controlled branch or non-TopGit branch is when those
631 commits are NOT reachable via any other ref!
633 Furthermore, while it is safe to rewrite merge commits (provided they meet the
634 same conditions) the merge commits themselves and the branches they are merging
635 in must be preserved during the rewrite and that can be rather tricky to get
636 right so it's not recommended.
638 For example, if, while working on a TopGit-controlled branch ``foo``, a bad
639 typo is noticed, it's okay to ammend/rebase to fix that provided neither
640 ``tg update`` nor ``tg create`` has already been used to cause some other ref
641 to be able to reach the commit with the typo.
643 If an amend or rerwite is done anyway even though the commit with the typo is
644 reachable from some other ref, the typo won't really be removed. What will
645 happen instead is that the new version without the typo will ultimately be
646 merged into the other ref(s) (at ``tg update`` time) likely causing a conflict
647 that will have to be manually resolved and the commit with the typo will
648 continue to be reachable from those other refs!
650 Instead just make a new commit to fix the typo. The end result will end up
651 being the same but without the merge conflicts.
653 See also the discussion in the `NO UNDO`_ section.
656 BARE BRANCHES
657 -------------
659 A "TopGit bare branch" (or just "bare branch" for short), refers to a TopGit
660 branch that has neither a ``.topdeps`` nor a ``.topmsg`` file stored in it.
661 And it's neither a new, still-empty empty branch nor an annihilated branch.
663 Such branches are not recommended but are reluctantly accomodated.
665 There are three situtations in which TopGit may encounter a TopGit branch
666 that has neither a ``.topdeps`` nor a ``.topmsg`` file.
668 1. Branch creation with ``--no-commit``
669 Before the initial commit is made, the branch will still be
670 pointing to the same commit as its "top-bases" ref. Branches
671 in this condition (where the branch and top-bases ref point to
672 the same commit) show up as having "No commits" in listings.
674 2. Annihilated branches
675 A branch is annihilated by making a new commit on the branch
676 that makes its tree identical to the tree of its corresponding
677 top-bases ref. Although the trees will be the same, the
678 commits will be different and annihilated branches are
679 distinguished from "No commits" branches in this way.
680 Annihilated branches are generally invisible and do not show up
681 in listings or other status displays. Intentionally so.
683 3. Bare branches
684 Any TopGit branch with neither a ``.topdeps`` file nor a
685 ``.topmsg`` file whose branch and top-bases trees differ falls
686 into this category. TopGit will not create such a branch
687 itself nor does it provide any commands to do so.
689 Whenever possible, a TopGit "[BASE]" branch should be preferred to using a
690 "bare branch" because a) it can never be mistaken for an annihilated branch,
691 b) it has a nice subject attached (via its ``.topmsg`` file) that shows
692 up in listings and c) exactly when and which updates are taken can be planned.
694 Nevertheless, situations may arise where it's useful to have TopGit treat a
695 branch as a "TopGit branch" so that it fully participates in all update
696 activities (such as updating local branches based on their remote branches),
697 but it's not feasible to turn it into a real "TopGit branch" as it comes from
698 an external source and rather than controlling exactly when and what updates
699 are picked up from it by TopGit (the precise use case of a "[BASE]" branch),
700 all updates that appear on it are to be assimilated as soon as they occur.
702 For this reason, TopGit will accomodate such "bare branches" but it will not
703 create (nor provide the means to create) them itself.
705 In order to create a "bare branch" all that's required is to create the
706 necessary top-bases ref. The choice of commit for the top-bases ref will
707 affect the output of the "files", "log" and "patch" commands most directly
708 (but all commands will be affected).
710 To work properly as a "bare branch", the commit the "bare branch"'s base points
711 to should be contained within the branch, be a different commit than the branch
712 tip itself and have a different tree than the branch tip. Simply setting the
713 base to the parent commit of the "bare branch" will usually work, but should
714 that commit at the tip of the "bare branch" end up getting reverted as the next
715 commit, the trees would match and it would appear to be an annihilated branch
716 rather than a "bare branch". That is one of the reasons these branches are not
717 recommended in the first place.
719 Setting the base to the root commit of the branch is more reliable and may
720 be accomplished like so for a local branch named "mybranch":
722 ::
724 git update-ref $(tg --top-bases)/mybranch \
725 $(git rev-list --first-parent --max-parents=0 mybranch) ""
727 Typically though it's more likely a remote bare branch will be needed. For
728 a remote named "origin" and a remote branch name of "vendor" this will do it:
730 ::
732 git update-ref $(tg --top-bases -r origin)/vendor \
733 $(git rev-list --first-parent --max-parents=0 origin/vendor) ""
735 Such "bare branches" are not likely ever to receive any more direct support in
736 TopGit than acknowleging they can be useful in some situations and tolerating
737 their existence by functioning properly with them even to the point of the
738 ``pre-commit`` hook tacitly allowing continued commits on such branches without
739 complaints about missing ``.topdeps`` and ``.topmsg`` files.
741 Note, however, that creating a regular TopGit branch that has no changes of its
742 own with the "bare branch" as its single dependency provides a means to supply
743 some kind of documentation if all other uses of the "bare branch" depend on
744 this "wrapper" branch instead of directly on the "bare branch".
747 SPEED AND CACHING
748 -----------------
750 TopGit needs to check many things to determine whether a TopGit branch is
751 up-to-date or not. This can involve a LOT of git commands for a complex
752 dependency tree. In order to speed things up, TopGit keeps a cache of results
753 in a ``tg-cache`` subdirectory in the ``.git`` directory.
755 Results are tagged with the original hash values used to get that result so
756 that items which have not been changed return their results quickly and items
757 which have been changed compute their new result and cache it for future use.
759 The ``.git/tg-cache`` directory may be removed at any time and the cache will
760 simply be recreated in an on-demand fashion as needed, at some speed penalty,
761 until it's fully rebuilt.
763 To force the cache to be fully pre-loaded, run the ``tg summary`` command
764 without any arguments. Otherwise, normal day-to-day TopGit operations should
765 keep it more-or-less up-to-date.
767 While each TopGit command is running, it uses a temporary subdirectory also
768 located in the ``.git`` directory. These directories are named
769 ``tg-tmp.XXXXXX`` where the ``XXXXXX`` part will be random letters and digits.
771 These temporary directories should always be removed automatically after each
772 TopGit command finishes running. As long as you are not in a subshell as a
773 result of a TopGit command stopping and waiting for a manual merge resolution,
774 it's safe to remove any of these directories that may have somehow accidentally
775 been left behind as a result of some failure that occurred while running a
776 TopGit command (provided, of course, it's not actually being used by a TopGit
777 command currently running in another terminal window or by another user on the
778 same repository).
781 USAGE
782 -----
783 ``tg [global options] <subcommand> [<subcommand option/argument>...]``
785 Global options:
787 ``[-C <dir>]... [-r <remote> | -u] [-c <name>=<val>]... [--no-pager]``
789 -C <dir> Change directory to <dir> before doing anything more
790 -r <remote> Pretend ``topgit.remote`` is set to <remote>
791 -u Pretend ``topgit.remote`` is not set
792 -c <name=val> Pass config option to git, may be repeated
793 --no-pager Disable use of any pager (by both TopGit and Git)
794 --top-bases Show full ``top-bases`` ref prefix and exit
795 --exec-path Show path to subcommand scripts location and exit
796 --help Show brief usage help and exit (aka ``-h``)
798 The ``tg`` tool has several subcommands:
800 :`tg annihilate`_: Mark a TopGit-controlled branch as defunct
801 :`tg base`_: Show base commit for one or more TopGit branches
802 :`tg checkout`_: Shortcut for git checkout with name matching
803 :`tg contains`_: Which TopGit-controlled branch contains the commit
804 :`tg create`_: Create a new TopGit-controlled branch
805 :`tg delete`_: Delete a TopGit-controlled branch cleanly
806 :`tg depend`_: Add a new dependency to a TopGit-controlled branch
807 :`tg export`_: Export TopGit branch patches to files or a branch
808 :`tg files`_: Show files changed by a TopGit branch
809 :`tg help`_: Show TopGit help optionally using a browser
810 :`tg import`_: Import commit(s) to separate TopGit branches
811 :`tg info`_: Show status information about a TopGit branch
812 :`tg log`_: Run git log limiting revisions to a TopGit branch
813 :`tg mail`_: Shortcut for git send-email with ``tg patch`` output
814 :`tg migrate-bases`_: Transition top-bases to new location
815 :`tg next`_: Show branches directly depending on a TopGit branch
816 :`tg patch`_: Generate a patch file for a TopGit branch
817 :`tg prev`_: Show non-annihilated TopGit dependencies for a branch
818 :`tg push`_: Run git push on TopGit branch(es) and depedencies
819 :`tg rebase`_: Auto continue git rebase if rerere resolves conflicts
820 :`tg remote`_: Set up remote for fetching/pushing TopGit branches
821 :`tg revert`_: Revert ref(s) to a state stored in a ``tg tag``
822 :`tg status`_: Show current TopGit status (e.g. in-progress update)
823 :`tg summary`_: Show various information about TopGit branches
824 :`tg tag`_: Create tag that records current TopGit branch state
825 :`tg update`_: Update TopGit branch(es) with respect to dependencies
827 tg help
828 ~~~~~~~
829 Our sophisticated integrated help facility. Mostly duplicates
830 what is below::
832 # to list commands:
833 $ tg help
834 # to get help for a particular command:
835 $ tg help <command>
836 # to get help for a particular command in a browser window:
837 $ tg help -w <command>
838 # to get help on TopGit itself
839 $ tg help tg
840 # to get help on TopGit itself in a browser
841 $ tg help -w tg
843 tg status
844 ~~~~~~~~~
845 Our sophisticated status facility. Similar to Git's status command
846 but shows any in-progress update that's awaiting a merge resolution
847 or any other on-going TopGit activity (such as a branch creation).
849 With a single ``--verbose`` (or ``-v``) option include a short status
850 display for any dirty (but not untracked) files. This also causes all
851 non file status lines to be prefixed with "## ".
853 With two (or more) ``--verbose`` (or ``-v``) options, additionally
854 show full symbolic ref names and unabbreviated hash values.
856 With the ``--exit-code`` option the exit code will be non-zero if any
857 TopGit or Git operation is currently in progress or the working
858 tree is unclean.
860 tg create
861 ~~~~~~~~~
862 Create a new TopGit-controlled topic branch of the given name
863 (required argument) and switch to it. If no dependencies are
864 specified (by extra arguments passed after the first one), the
865 current branch is assumed to be the only dependency.
867 By default ``tg create`` opens an editor on the new ``.topmsg`` file
868 and then commits the new ``.topmsg`` and ``.topdeps`` files
869 automatically with a suitable default commit message.
871 The commit message can be changed with the ``-m`` (or ``--message``) or
872 ``-F`` (or ``--file``) option. The automatic commit can be suppressed
873 by using the ``--no-ccmmit`` option. Running the editor on the new
874 ``.topmsg`` file can be suppressed by using ``-n`` (or ``--no-edit``)
875 (which also suppresses the automatic commit) or by providing an
876 explicit value for the new ``.topmsg`` file using the ``--topmsg`` or
877 ``--topmsg-file`` option. In any case the ``.topmsg`` content will be
878 automatically reformated to have a ``Subject:`` header line if needed.
880 If the ``format.signoff`` config variable (see ``git help config``)
881 has been set to true then the ``Signed-off-by:`` header line added to
882 the end of the initial version of the ``.topmsg`` file will be
883 uncommented by default. Otherwise it will still be there but will be
884 commented out and will be automatically stripped if no action is taken
885 to remove the comment character.
887 If more than one dependency is listed an automatic ``tg update`` runs
888 after the branch has been created to merge in the additional
889 dependencies and bring the branch up-to-date. This can be suppressed
890 with the ``--no-commit`` option (which also suppresses the initial
891 commit).
893 Previous versions of TopGit behaved as though the ``--no-edit`` option
894 was always given on the command line.
896 The default behavior has been changed to promote a separation between
897 commits that modify ``.topmsg`` and/or ``.topdeps`` and commits that
898 modify other files. This facilitates cleaner cherry picking and other
899 patch maintenance activities.
901 You should edit the patch description (contained in the ``.topmsg``
902 file) as appropriate. It will already contain some prefilled bits.
903 You can set the ``topgit.to``, ``topgit.cc`` and ``topgit.bcc``
904 git configuration variables (see ``man git-config``) in order to
905 have ``tg create`` add these headers with the given default values
906 to ``.topmsg`` before invoking the editor. If the configuration
907 variable ``topgit.subjectPrefix`` is set its value will be inserted
908 *between* the initial ``[`` and the word ``PATCH`` in the subject
909 line (with a space added before the word ``PATCH`` of course).
911 The main task of ``tg create`` is to set up the topic branch base
912 from the dependencies. This may fail due to merge conflicts if more
913 than one dependency is given. In that case, after you commit the
914 conflict resolution, you should call ``tg update --continue`` to
915 finish merging the dependencies into the new topic branch base.
917 With the ``--base`` (aka ``--no-deps``) option at most one dependency
918 may be listed which may be any valid committish (instead of just
919 refs/heads/...) and the newly created TopGit-controlled branch will
920 have an empty ``.topdeps`` file. This may be desirable in order to
921 create a TopGit-controlled branch that has no changes of its own and
922 serves merely to mark the common dependency that all other
923 TopGit-controlled branches in some set of TopGit-controlled branches
924 depend on. A plain, non-TopGit-controlled branch can be used for the
925 same purpose, but the advantage of a TopGit-controlled branch with no
926 dependencies is that it will be pushed with ``tg push``, it will show
927 up in the ``tg summary`` and ``tg info`` output with the subject from
928 its ``.topmsg`` file thereby documenting what it's for and finally it
929 can be set up with ``tg create -r`` and/or ``tg remote --populate`` to
930 facilitate sharing.
932 For example, ``tg create --base release v2.1`` will create a TopGit-
933 controlled ``release`` branch based off the ``v2.1`` tag that can then
934 be used as a base for creation of other TopGit-controlled branches.
935 Then when the time comes to move the base for an entire set of changes
936 up to ``v2.2`` the command ``tg update --base release v2.2`` can be
937 used followed by ``tg update --all``.
939 Using ``--base`` it's also possible to use ``tg create`` on an
940 unborn branch (omit the dependency name or specify ``HEAD``). The
941 unborn branch itself can be made into the new TopGit branch (rather
942 than being born empty and then having the new TopGit branch based off
943 that) by specifying ``HEAD`` as the new branch's name (which is
944 probably what you normally want to do in this case anyway so you can
945 just run ``tg create --base HEAD`` to accomplish that).
947 In an alternative use case, if ``-r <branch>`` is given instead of a
948 dependency list, the topic branch is created based on the given
949 remote branch. With just ``-r`` the remote branch name is assumed
950 to be the same as the local topic branch being created. Since no
951 new commits are created in this mode (only two refs will be updated)
952 the editor will never be run for this use case. Note that no other
953 options may be combined with ``-r``.
955 The ``--quiet`` (or ``-q``) option suppresses most informational
956 messages.
958 tg delete
959 ~~~~~~~~~
960 Remove a TopGit-controlled topic branch of the given name
961 (required argument). Normally, this command will remove only an
962 empty branch (base == head) without dependents; use ``-f`` to
963 remove a non-empty branch or a branch that is depended upon by
964 another branch.
966 The ``-f`` option is also useful to force removal of a branch's
967 base, if you used ``git branch -D B`` to remove branch B, and then
968 certain TopGit commands complain, because the base of branch B
969 is still there.
971 Normally ``tg delete`` will refuse to delete the current branch.
972 However, giving ``-f`` twice (or more) will force it to do so but it
973 will first detach your HEAD.
975 IMPORTANT: Currently, this command will *NOT* remove the branch
976 from the dependency list in other branches. You need to take
977 care of this *manually*. This is even more complicated in
978 combination with ``-f`` -- in that case, you need to manually
979 unmerge the removed branch's changes from the branches depending
980 on it.
982 The same ``--stash`` and ``--no-stash`` options are accepted with
983 the same exact semantics as for `tg update`_.
985 See also ``tg annihilate``.
987 | TODO: ``-a`` to delete all empty branches, depfix, revert
989 tg annihilate
990 ~~~~~~~~~~~~~
991 Make a commit on the current or given TopGit-controlled topic
992 branch that makes it equal to its base, including the presence or
993 absence of .topmsg and .topdeps. Annihilated branches are not
994 displayed by ``tg summary``, so they effectively get out of your
995 way. However, the branch still exists, and ``tg push`` will
996 push it (except if given the ``-a`` option). This way, you can
997 communicate that the branch is no longer wanted.
999 When annihilating a branch that has dependents (i.e. branches
1000 that depend on it), those dependents have the dependencies of
1001 the branch being annihilated added to them if they do not already
1002 have them as dependencies. Essentially the DAG is repaired to
1003 skip over the annihilated branch.
1005 Normally, this command will remove only an empty branch
1006 (base == head, except for changes to the .top* files); use
1007 ``-f`` to annihilate a non-empty branch.
1009 After completing the annihilation itself, normally ``tg update``
1010 is run on any modified dependents. Use the ``--no-update`` option
1011 to suppress running ``tg update``.
1013 The same ``--stash`` and ``--no-stash`` options are accepted with
1014 the same exact semantics as for `tg update`_.
1016 tg depend
1017 ~~~~~~~~~
1018 Change the dependencies of a TopGit-controlled topic branch.
1019 This should have several subcommands, but only ``add`` is
1020 supported right now.
1022 The ``add`` subcommand takes an argument naming a topic branch to
1023 be added, adds it to ``.topdeps``, performs a commit and then
1024 updates your topic branch accordingly. If you want to do other
1025 things related to the dependency addition, like adjusting
1026 ``.topmsg``, use the option ``--no-commit``. Adding the
1027 ``--no-update`` (or ``--no-commit``) option will suppress the
1028 ``tg update`` normally performed after committing the change.
1030 It is safe to run ``tg depend add`` in a dirty worktree, but the
1031 normally performed ``tg update`` will be suppressed in that case
1032 (even if neither ``--no-update`` nor ``--no-commit`` is given).
1034 You have enabled ``git rerere`` haven't you?
1036 | TODO: Subcommand for removing dependencies, obviously
1038 tg files
1039 ~~~~~~~~
1040 List files changed by the current or specified topic branch.
1042 Options:
1043 -i list files based on index instead of branch
1044 -w list files based on working tree instead of branch
1046 tg info
1047 ~~~~~~~
1048 Show summary information about the current or specified topic
1049 branch.
1051 Numbers in parenthesis after a branch name such as "(11/3 commits)"
1052 indicate how many commits on the branch (11) and how many of those
1053 are non-merge commits (3).
1055 With ``--verbose`` (or ``-v``) include a list of dependents (i.e. other
1056 branches that depend on this one). Another ``--verbose`` annotates
1057 them with "[needs merge]" if the current tip of branch for which info
1058 is being shown has not yet been merged into the base of the dependent.
1060 Alternatively, if ``--heads`` is used then which of the independent
1061 TopGit branch heads (as output by ``tg summary --topgit-heads``)
1062 logically contains the specified commit (which may be any committish --
1063 defaults to ``HEAD`` if not given). Zero or more results will be
1064 output. Note that "logically" means with regard to the TopGit
1065 dependency relationships as established by the ``.topdeps`` file(s).
1066 It's the answer that would be given when all the TopGit branches are
1067 up-to-date (even though they need not be to use this option) and the
1068 ``git branch --contains`` command is run and the output then filtered
1069 to only those branches that appear in ``tg summary --topgit-heads``.
1070 This computation may require several seconds on complex repositories.
1072 If ``--leaves`` is used then the unique list of leaves of the current
1073 or specified topic branch is shown as one fully-qualified ref per line.
1074 Duplicates are suppressed and a tag name will be used when appropriate.
1075 A "leaf" is any dependency that is either not a TopGit branch or is
1076 the base of a non-annihilated TopGit branch with no non-annihilated
1077 dependencies.
1079 The ``--deps`` option shows non-annihilated TopGit dependencies of the
1080 specified branch (default is ``HEAD``). (It can also be spelled out
1081 as ``--dependencies`` for the pedantically inclined.)
1083 The ``--dependents`` option shows non-annihilated TopGit dependents
1084 (i.e. branches that depend on the specified branch). The default
1085 branch to operate on is again ``HEAD``.
1087 A linearized patch series can only be automatically created for a
1088 TopGit topic branch (including its recursive dependencies) when exactly
1089 one line is output by ``tg info --leaves <topic-branch>``.
1091 With ``--series`` the list of TopGit branches in the order they would
1092 be linearized into a patch series is shown along with the description
1093 of each branch. If branch name passed to ``tg info`` is not the last
1094 branch in the series a marker column will be provided to quickly
1095 locate it in the list. This same option can be used with `tg checkout`_.
1097 Some patches shown in the list may not actually end up introducing any
1098 changes if exported and be therefore end up being omitted. The ``0``
1099 indicator in ``tg summary`` output can help to identify some of these.
1101 The patches shown in the series in the order they are shown form the
1102 basis for the ``tg next`` and ``tg prev`` operations with the first
1103 patch shown being considered the first and so on up to the last.
1105 tg patch
1106 ~~~~~~~~
1107 Generate a patch from the current or specified topic branch.
1108 This means that the diff between the topic branch base and head
1109 (latest commit) is shown, appended to the description found in
1110 the ``.topmsg`` file.
1112 The patch is simply dumped to stdout. In the future, ``tg patch``
1113 will be able to automatically send the patches by mail or save
1114 them to files. (TODO)
1116 Options:
1117 -i base patch generation on index instead of branch
1118 -w base patch generation on working tree instead of branch
1119 --binary pass --binary to ``git diff-tree`` to enable generation
1120 of binary patches
1121 --quiet be quiet (aka ``-q``) about missing and unfixed From:
1122 --from make sure patch has a From: line, if not add one using
1123 --from=<a> <a> or Signed-off-by value or ident value; ``git am``
1124 really gets unhappy with patches missing From: lines;
1125 will NOT replace an existing non-empty From: header
1126 --no-from leave all From: lines alone, missing or not (default)
1127 --diff-opt options after the branch name (and an optional ``--``)
1128 are passed directly to ``git diff-tree``
1130 In order to pass a sole explicit ``-w`` through to ``git diff-tree`` it
1131 must be separated from the ``tg`` options by an explicit ``--``.
1132 Or it can be spelled as ``--ignore-all-space`` to distinguuish it from
1133 ``tg``'s ``-w`` option.
1135 If the config variable ``topgit.from`` is set to a boolean it can be
1136 used to enable or disable the ``--from`` option by default. If it's
1137 set to the speical value ``quiet`` the ``--quiet`` option is enabled
1138 and From: lines are left alone by default. Any other non-empty value
1139 is taken as a default ``--from=<value>`` option. The ``--no-from``
1140 option will temporarily disable use of the config value.
1142 If additional non-``tg`` options are passed through to
1143 ``git diff-tree`` (other than ``--binary`` which is fully supported)
1144 the resulting ``tg patch`` output may not be appliable.
1146 tg mail
1147 ~~~~~~~
1148 Send a patch from the current or specified topic branch as
1149 email(s).
1151 Takes the patch given on the command line and emails it out.
1152 Destination addresses such as To, Cc and Bcc are taken from the
1153 patch header.
1155 Since it actually boils down to ``git send-email``, please refer
1156 to the documentation for that for details on how to setup email
1157 for git. You can pass arbitrary options to this command through
1158 the ``-s`` parameter, but you must double-quote everything. The
1159 ``-r`` parameter with a msgid can be used to generate in-reply-to
1160 and reference headers to an earlier mail.
1162 WARNING: be careful when using this command. It easily sends
1163 out several mails. You might want to run::
1165 git config sendemail.confirm always
1167 to let ``git send-email`` ask for confirmation before sending any
1168 mail.
1170 Options:
1171 -i base patch generation on index instead of branch
1172 -w base patch generation on working tree instead of branch
1174 | TODO: ``tg mail patchfile`` to mail an already exported patch
1175 | TODO: mailing patch series
1176 | TODO: specifying additional options and addresses on command line
1178 tg remote
1179 ~~~~~~~~~
1180 Register the given remote as TopGit-controlled. This will create
1181 the namespace for the remote branch bases and teach ``git fetch``
1182 to operate on them. However, from TopGit 0.8 onwards you need to
1183 use ``tg push``, or ``git push --mirror``, for pushing
1184 TopGit-controlled branches.
1186 ``tg remote`` takes an optional remote name argument, and an
1187 optional ``--populate`` switch. Use ``--populate`` for your
1188 origin-style remotes: it will seed the local topic branch system
1189 based on the remote topic branches. ``--populate`` will also make
1190 ``tg remote`` automatically fetch the remote, and ``tg update`` look
1191 at branches of this remote for updates by default.
1193 Using ``--populate`` with a remote name causes the ``topgit.remote``
1194 git configuration variable to be set to the given remote name.
1196 tg summary
1197 ~~~~~~~~~~
1198 Show overview of all TopGit-tracked topic branches and their
1199 up-to-date status. With a branch name limit output to that branch.
1200 Using ``--deps-only`` or ``--rdeps`` changes the default from all
1201 related branches to just the current ``HEAD`` branch but using
1202 ``--all`` as the branch name will show results for all branches
1203 instead of ``HEAD``.
1205 ``>``
1206 marks the current topic branch
1208 ``0``
1209 indicates that it introduces no changes of its own
1211 ``l``/``r``
1212 indicates respectively whether it is local-only
1213 or has a remote mate
1215 ``L``/``R``
1216 indicates respectively if it is ahead or out-of-date
1217 with respect to its remote mate
1219 ``D``
1220 indicates that it is out-of-date with respect to its
1221 dependencies
1223 ``!``
1224 indicates that it has missing dependencies [even if
1225 they are recursive ones]
1227 ``B``
1228 indicates that it is out-of-date with respect to
1229 its base
1231 ``*``
1232 indicates it is ahead of (and needs to be merged into)
1233 at least one of its dependents -- only computed when
1234 showing all branches or using the (possibly implied)
1235 ``--with-deps`` option.
1237 This can take a longish time to accurately determine all the
1238 relevant information about each branch; you can pass ``-t`` (or ``-l``
1239 or ``--list``) to get just a terse list of topic branch names quickly.
1240 Also adding ``--verbose`` (or ``-v``) includes the subjects too.
1242 If no options or arguments are passed, the default is not actually to
1243 show ``--all`` branches (that was the default once upon a time).
1244 Instead, the default is essentially ``--with-deps $(tg info --heads)``
1245 with a fallback to ``--all`` if ``tg info`` doesn't give up any heads.
1246 This usually provides a more intuitive result. Explicitly using
1247 ``--all`` will always show all branches (related or not to ``HEAD``).
1249 Passing ``--heads`` shows independent topic branch names and when
1250 combined with ``--rdeps`` behaves as though ``--rdeps`` were run with
1251 the output of ``--heads``.
1253 The ``--heads-independent`` option works just like ``--heads`` except
1254 that it computes the heads using ``git merge-base --independent``
1255 rather than examining the TopGit ``.topdeps`` relationships. If the
1256 TopGit branches are all up-to-date (as shown in ``tg summary``) then
1257 both ``--heads`` and ``--heads-independent`` should compute the same
1258 list of heads (unless some overlapping TopGit branches have been
1259 manually created). If not all the TopGit branches are up-to-date then
1260 the ``--heads-independent`` results may have extra items in it, but
1261 occasionally that's what's needed; usually it's the wrong answer.
1262 (Note that ``--topgit-heads`` is accepted as an alias for ``--heads``
1263 as well.)
1265 Using ``--heads-only`` behaves as though the output of ``--heads`` was
1266 passed as the list of branches along with ``--without-deps``.
1268 Alternatively, you can pass ``--graphviz`` to get a dot-suitable output
1269 for drawing a dependency graph between the topic branches.
1271 You can also use the ``--sort`` option to sort the branches using
1272 a topological sort. This is especially useful if each
1273 TopGit-tracked topic branch depends on a single parent branch,
1274 since it will then print the branches in the dependency order.
1275 In more complex scenarios, a text graph view would be much more
1276 useful, but that has not yet been implemented.
1278 The ``--deps`` option outputs dependency information between
1279 branches in a machine-readable format. Feed this to ``tsort`` to
1280 get the output from --sort.
1282 The ``--deps-only`` option outputs a sorted list of the unique branch
1283 names given on the command line plus all of their recursive
1284 dependencies (subject to ``--exclude`` of course). When
1285 ``--deps-only`` is given the default is to just display information for
1286 ``HEAD``, but that can be changed by using ``--all`` as the branch
1287 name. Each branch name will appear only once in the output no matter
1288 how many times it's visited while tracing the dependency graph or how
1289 many branch names are given on the command line to process.
1291 The ``--rdeps`` option outputs dependency information in an indented
1292 text format that clearly shows all the dependencies and their
1293 relationships to one another. When ``--rdeps`` is given the default is
1294 to just display information for ``HEAD``, but that can be changed by
1295 using ``--all`` as the branch name or by adding the ``--heads`` option.
1296 Note that ``tg summary --rdeps --heads`` can be particularly helpful in
1297 seeing all the TopGit-controlled branches in the repository and their
1298 relationships to one another.
1300 Note that ``--rdeps`` has two flavors. The first (and default) is
1301 ``--rdeps-once`` which only shows the dependencies of a branch when
1302 it's first visited. For example, if D depends on several other
1303 branches perhaps recursively and both branch A and B depend on D, then
1304 whichever of A or B is shown first will show the entire dependency
1305 chain for D underneath it and the other one will just show a line for
1306 D itself. This can make the output a bit more compact without actually
1307 losing any information which is why it's the default. However, using
1308 the ``--rdeps-full`` variant will repeat the full dependency chain
1309 every time it's encountered.
1311 Adding ``--with-deps`` replaces the given list of branches (which will
1312 default to ``HEAD`` if none are given) with the result of running
1313 ``tg summary --deps-only --tgish`` on the list of branches. This can
1314 be helpful in limiting ``tg summary`` output to only the list of given
1315 branches and their dependencies when many TopGit-controlled branches
1316 are present in the repository. When it would be allowed,
1317 ``--with-deps`` is now the default. Use ``--without-deps`` to switch
1318 back to the old behavior.
1320 With ``--exclude branch``, branch can be excluded from the output
1321 meaning it will be skipped and its name will be omitted from any
1322 dependency output. The ``--exclude`` option may be repeated to omit
1323 more than one branch from the output. Limiting the output to a single
1324 branch that has been excluded will result in no output at all.
1326 The ``--tgish-only`` option behaves as though any non-TopGit-controlled
1327 dependencies encountered during processing had been listed after an
1328 ``--exclude`` option.
1330 Note that the branch name can be specified as ``HEAD`` or ``@`` as a
1331 shortcut for the TopGit-controlled branch that ``HEAD`` is a
1332 symbolic ref to. The ``tg summary @`` command can be quite useful.
1334 Options:
1335 -i Use TopGit metadata from the index instead of the branch
1336 -w Use TopGit metadata from the working tree instead of the branch
1338 tg contains
1339 ~~~~~~~~~~~
1340 Search all TopGit-controlled branches (and optionally their remotes)
1341 to find which TopGit-controlled branch contains the specified commit.
1343 This is more than just basic branch containment as provided for by the
1344 ``git branch --contains`` command. While the shown branch name(s)
1345 will, indeed, be one (or more) of those output by the
1346 ``git branch --contains`` command, the result(s) will exclude any
1347 TopGit-controlled branches from the result(s) that have one (or more)
1348 of their TopGit dependencies (either direct or indirect) appearing in
1349 the ``git branch --contains`` output.
1351 Normally the result will be only the one, single TopGit-controlled
1352 branch for which the specified committish appears in the ``tg log``
1353 output for that branch (unless the committish lies outside the
1354 TopGit-controlled portion of the DAG and ``--no-strict`` was used).
1356 Unless ``--annihilated-okay`` (or ``--ann`` or ``--annihilated``) is
1357 used then annihilated branches will be immediately removed from the
1358 ``git branch --contains`` output before doing anything else. This
1359 means a committish that was originally located in a now-annihilated
1360 branch will show up in whatever branch picked up the annihilated
1361 branch's changes (if there is one). This is usually the correct
1362 answer, but occasionally it's not; hence this option. If this option
1363 is used together with ``--verbose`` then annihilated branches will
1364 be shown as "[:annihilated:]".
1366 In other words, if a ``tg patch`` is generated for the found branch
1367 (assuming one was found and a subsequent commit in the same branch
1368 didn't then revert or otherwise back out the change), then that patch
1369 will include the changes introduced by the specified committish
1370 (unless, of course, that committish is outside the TopGit-controlled
1371 portion of the DAG and ``--no-strict`` was given).
1373 This can be very helpful when, for example, a bug is discovered and
1374 then after using ``git bisect`` (or some other tool) to find the
1375 offending commit it's time to commit the fix. But because the
1376 TopGit merging history can be quite complicated and maybe the one
1377 doing the fix wasn't the bug's author (or the author's memory is just
1378 going), it can sometimes be rather tedious to figure out which
1379 TopGit branch the fix belongs in. The ``tg contains`` command can
1380 quickly tell you the answer to that question.
1382 With the ``--remotes`` (or ``-r``) option a TopGit-controlled remote
1383 branch name may be reported as the result but only if there is no
1384 non-remote branch containing the committish (this can only happen
1385 if at least one of the TopGit-controlled local branches are not yet
1386 up-to-date with their remotes).
1388 With the ``--verbose`` option show which TopGit DAG head(s) (one or
1389 more of the TopGit-controlled branch names output by
1390 ``tg summary --heads``) have the result as a dependency (either direct
1391 or indirect). Using this option will noticeably increase running time.
1393 With the default ``--strict`` option, results for which the base of the
1394 TopGit-controlled branch contains the committish will be suppressed.
1395 For example, if the committish was deep-down in the master branch
1396 history somewhere far outside of the TopGit-controlled portion of
1397 the DAG, with ``--no-strict``, whatever TopGit-controlled branch(es)
1398 first picked up history containing that committish will be shown.
1399 While this is a useful result it's usually not the desired result
1400 which is why it's not the default.
1402 To summarize, even with ``--remotes``, remote results are only shown
1403 if there are no non-remote results. Without ``--no-strict`` (because
1404 ``--strict`` is the default) results outside the TopGit-controlled
1405 portion of the DAG are never shown and even with ``--no-strict`` they
1406 will only be shown if there are no ``--strict`` results. Finally,
1407 the TopGit head info shown with ``--verbose`` only ever appears for
1408 local (i.e. not a remote branch) results. Annihilated branches are
1409 never considered possible matches without ``--annihilated-okay``.
1411 tg checkout
1412 ~~~~~~~~~~~
1413 Switch to a topic branch. You can use ``git checkout <branch>``
1414 to get the same effect, but this command helps you navigate
1415 the dependency graph, or allows you to match the topic branch
1416 name using a regular expression, so it can be more convenient.
1418 The ``--branch`` (or ``-b`` or ``--branch=<name>``) option changes
1419 the default starting point from ``HEAD`` to the specified branch.
1421 For the "next" and "previous" commands, the ``<steps>`` value may
1422 be ``--all`` (or ``-a``) to take "As many steps As possible" or
1423 "step ALL the way" or "ALL steps at once" (or make something better
1424 up yourself).
1426 The following subcommands are available:
1428 ``tg checkout next [<steps>]``
1429 Check out a branch that directly
1430 depends on your current branch.
1431 Move ``<steps>`` (default 1) step(s) in
1432 the "next" direction (AKA ``n``).
1434 ``tg checkout prev [<steps>]``
1435 Check out a branch that this branch
1436 directly depends on. Move ``<steps>``
1437 (default 1) step(s) in the "previous"
1438 direction (AKA ``p`` or ``previous``).
1440 ``tg checkout [goto] [--] <pattern>``
1441 Check out a topic branch that
1442 matches ``<pattern>``. ``<pattern>``
1443 is used as a grep ERE pattern to filter
1444 all the topic branches. Both ``goto`` and
1445 ``--`` may be omitted provided ``<pattern>``
1446 is not ``-a``, ``--all``, ``-h``, ``--help``,
1447 ``goto``, ``--``, ``n``, ``next``, ``push``,
1448 ``child``, ``p``, ``prev``, ``previous``,
1449 ``pop``, ``parent`` or ``..``.
1451 ``tg checkout [goto] [--] --series[=<head>]``
1452 Check out a topic branch that belongs to
1453 the current (or ``<head>``) patch series.
1454 A list with descriptions (``tg info --series``)
1455 will be shown to choose from if more than one.
1457 ``tg checkout push [<steps>]``
1458 An alias for ``next``.
1460 ``tg checkout child [<steps>]``
1461 Deprecated alias for ``next``.
1463 ``tg checkout``
1464 Semi-deprecated alias for ``next``.
1466 ``tg checkout pop [<steps>]``
1467 An alias for ``prev``.
1469 ``tg checkout parent [<steps>]``
1470 Deprecated alias for ``prev``.
1472 ``tg checkout .. [<steps>]``
1473 Semi-deprecated alias for ``prev``.
1475 If any of the above commands can find more than one possible
1476 branch to switch to, you will be presented with the matches
1477 and asked to select one of them.
1479 If the ``--ignore-other-worktrees`` (or ``--iow``) option is given and
1480 the current Git version is at least 2.5.0 then the full
1481 ``--ignore-other-worktrees`` option will be passed along to the
1482 ``git checkout`` command when it's run (otherwise the option will be
1483 silently ignored and not passed to Git as it would cause an error).
1485 The ``--force`` (or ``-f``) option, when given, gets passed through to
1486 the ``git checkout`` command.
1488 The ``--merge`` (or ``-m``) option, when given, gets passed through to
1489 the ``git checkout`` command.
1491 The ``--quiet`` (or ``-q``) option, when given, gets passed through to
1492 the ``git checkout`` command.
1494 The ``<pattern>`` of ``tg checkout goto`` is optional. If you don't
1495 supply it, all the available topic branches are listed and you
1496 can select one of them.
1498 Normally, the ``next`` and ``prev`` commands moves one step in
1499 the dependency graph of the topic branches. The ``-a`` option
1500 causes them (and their aliases) to move as far as possible.
1501 That is, ``tg checkout next -a`` moves to a topic branch that
1502 depends (directly or indirectly) on the current branch and
1503 that no other branch depends on. ``tg checkout prev -a``
1504 moves to a topic branch that the current topic branch
1505 depends on (directly or indirectly). If there is more than
1506 one possibility, you will be prompted for your selection.
1508 See also NAVIGATION_.
1510 tg export
1511 ~~~~~~~~~
1512 Export a tidied-up history of the current topic branch and its
1513 dependencies, suitable for feeding upstream. Each topic branch
1514 corresponds to a single commit or patch in the cleaned up
1515 history (corresponding basically exactly to ``tg patch`` output
1516 for the topic branch).
1518 The command has three possible outputs now -- either a Git branch
1519 with the collapsed history, a Git branch with a linearized
1520 history, or a quilt series in new directory.
1522 In the case where you are producing collapsed history in a new
1523 branch, you can use this collapsed structure either for
1524 providing a pull source for upstream, or for further
1525 linearization e.g. for creation of a quilt series using git log::
1527 git log --pretty=email -p --topo-order origin..exported
1529 To better understand the function of ``tg export``, consider this
1530 dependency structure::
1532 origin/master - t/foo/blue - t/foo/red - master
1533 `- t/bar/good <,----------'
1534 `- t/baz ------------'
1536 (where each of the branches may have a hefty history). Then::
1538 master$ tg export for-linus
1540 will create this commit structure on the branch ``for-linus``::
1542 origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
1543 `- t/bar/good <,-------------------'/
1544 `- t/baz ---------------------'
1546 In this mode, ``tg export`` works on the current topic branch, and
1547 can be called either without an option (in that case,
1548 ``--collapse`` is assumed), or with the ``--collapse`` option, and
1549 with one mandatory argument: the name of the branch where the
1550 exported result will be stored.
1552 When using the linearize mode::
1554 master$ tg export --linearize for-linus
1556 you get a linear history respecting the dependencies of your
1557 patches in a new branch ``for-linus``. The result should be more
1558 or less the same as using quilt mode and then reimporting it
1559 into a Git branch. (More or less because the topological order
1560 can usually be extended in more than one way into a total order,
1561 and the two methods may choose different ones.) The result
1562 might be more appropriate for merging upstream, as it contains
1563 fewer merges.
1565 Note that you might get conflicts during linearization because
1566 the patches are reordered to get a linear history. If linearization
1567 would produce conflicts then using ``--quilt`` will also likely result
1568 in conflicts when the exported quilt series is applied. Since the
1569 ``--quilt`` mode simply runs a series of ``tg patch`` commands to
1570 generate the patches in the exported quilt series and those patches
1571 will end up being applied linearly, the same conflicts that would be
1572 produced by the ``--linearize`` option will then occur at that time.
1574 To avoid conflicts produced by ``--linearize`` (or by applying the
1575 ``--quilt`` output), use the default ``--collapse`` mode and then use
1576 ``tg rebase`` (or ``git rebase -m`` directly) on the collapsed branch
1577 (with a suitable <upstream>) followed by ``git format-patch`` on the
1578 rebased result to produce a conflict-free patch set. A suitable
1579 upstream may be determined with the ``tg info --leaves`` command (if
1580 it outputs more than one line, linearization will be problematic).
1582 You have enabled ``git rerere`` haven't you?
1584 When using the quilt mode::
1586 master$ tg export --quilt for-linus
1588 would create the following directory ``for-linus``::
1590 for-linus/t/foo/blue.diff
1591 for-linus/t/foo/red.diff
1592 for-linus/t/bar/good.diff
1593 for-linus/t/baz.diff
1594 for-linus/series:
1595 t/foo/blue.diff -p1
1596 t/bar/good.diff -p1
1597 t/foo/red.diff -p1
1598 t/baz.diff -p1
1600 With ``--quilt``, you can also pass the ``-b`` parameter followed
1601 by a comma-separated explicit list of branches to export, or
1602 the ``--all`` parameter (which can be shortened to ``-a``) to
1603 export them all. The ``--binary`` option enables producing Git
1604 binary patches. These options are currently only supported
1605 with ``--quilt``.
1607 In ``--quilt`` mode the patches are named like the originating
1608 topgit branch. So usually they end up in subdirectories of the
1609 output directory. With the ``--flatten`` option the names are
1610 mangled so that they end up directly in the output dir (slashes
1611 are replaced with underscores). With the ``--strip[=N]`` option
1612 the first ``N`` subdirectories (all if no ``N`` is given) get
1613 stripped off. Names are always ``--strip``'d before being
1614 ``--flatten``'d. With the option ``--numbered`` (which implies
1615 ``--flatten``) the patch names get a number as prefix to allow
1616 getting the order without consulting the series file, which
1617 eases sending out the patches.
1619 | TODO: Make stripping of non-essential headers configurable
1620 | TODO: Make stripping of [PATCH] and other prefixes configurable
1621 | TODO: ``--mbox`` option to export instead as an mbox file
1622 | TODO: support ``--all`` option in other modes of operation
1623 | TODO: For quilt exporting, export the linearized history created in
1624 a temporary branch--this would allow producing conflict-less
1625 series
1627 tg import
1628 ~~~~~~~~~
1629 Import commits within the given revision range(s) into TopGit,
1630 creating one topic branch per commit. The dependencies are set
1631 up to form a linear sequence starting on your current branch --
1632 or a branch specified by the ``-d`` parameter, if present.
1634 The branch names are auto-guessed from the commit messages and
1635 prefixed by ``t/`` by default; use ``-p <prefix>`` to specify an
1636 alternative prefix (even an empty one).
1638 Each "<range>" must be of the form <rev1>..<rev2> where either
1639 <rev1> or <rev2> can be omitted to mean HEAD. Additionally the
1640 shortcut <rev>^! (see ``git help revisions``) is permitted as a
1641 "<range>" to select the single commit <rev> but only if the
1642 commit <rev> has *exactly* one parent. This is really just a
1643 shortcut for <rev>^..<rev> but somewhat safer since it will fail
1644 if <rev> has other than one parent.
1646 Alternatively, you can use the ``-s NAME`` parameter to specify
1647 the name of the target branch; the command will then take one
1648 more argument describing a *single* commit to import (which may
1649 have any number of parents).
1651 tg update
1652 ~~~~~~~~~
1653 Update the current, specified or all topic branches with respect
1654 to changes in the branches they depend on and remote branches.
1655 This is performed in two phases -- first, changes within the
1656 dependencies are merged to the base, then the base is merged
1657 into the topic branch. The output will guide you on what to do
1658 next in case of conflicts.
1660 You have enabled ``git rerere`` haven't you?
1662 The ``--[no-]auto[-update]`` options together with the
1663 ``topgit.setAutoUpdate`` config item control whether or not TopGit
1664 will automatically temporarily set ``rerere.autoUpdate`` to true while
1665 running ``tg update``. The default is true. Note that this does not
1666 enable Git's ``rerere`` feature, it merely makes it automatically stage
1667 any previously resolved conflicts. The ``rerere.enabled`` setting must
1668 still be separately enabled (i.e. set to ``true``) for the ``rerere``
1669 feature to do anything at all.
1671 Using ``--auto[-update]`` makes ``tg update`` always temporarily set
1672 ``rerere.autoUpdate`` to ``true`` while running ``tg update``. The
1673 ``--no-auto[-update]`` option prevents ``tg update`` from changing the
1674 ``rerere.autoUpdate`` setting, but if ``rerere.autoUpdate`` has already
1675 been enabled in a config file, ``tg update`` never disables it even
1676 with ``--no-auto``. If ``topgit.setAutoUpdate`` is unset or set to
1677 ``true`` then ``tg update`` implicitly does ``--auto``, otherwise it
1678 does ``--no-auto``. An explicit command line ``--[no-]auto[-update]``
1679 option causes the ``topgit.setAutoUpdate`` setting to be ignored.
1681 When both ``rerere.enabled`` and ``rerere.autoUpdate`` are set to true
1682 then ``tg update`` will be able to automatically continue an update
1683 whenever ``git rerere`` resolves all the conflicts during a merge.
1684 This can be such a huge time saver. That's why the default is to have
1685 TopGit automatically set ``rerere.autoUpdate`` to true while
1686 ``tg update`` is running (but remember, unless ``rerere.enabled`` has
1687 been set to ``true`` it won't make any difference).
1689 When ``-a`` (or ``--all``) is specified, updates all topic branches
1690 matched by ``<pattern>``'s (see ``git-for-each-ref(1)`` for details),
1691 or all if no ``<pattern>`` is given. Any topic branches with missing
1692 dependencies will be skipped entirely unless ``--skip-missing`` is
1693 specified.
1695 When ``--skip-missing`` is specified, an attempt is made to update topic
1696 branches with missing dependencies by skipping only the dependencies
1697 that are missing. Caveat utilitor.
1699 When ``--stash`` is specified (or the ``topgit.autostash`` config
1700 value is set to ``true``), a ref stash will be automatically created
1701 just before beginning updates if any are needed. The ``--no-stash``
1702 option may be used to disable a ``topgit.autostash=true`` setting.
1703 See the ``tg tag`` ``--stash`` option for details.
1705 After the update, if a single topic branch was specified, it is
1706 left as the current one; if ``-a`` was specified, it returns to
1707 the branch which was current at the beginning.
1709 If your dependencies are not up-to-date, ``tg update`` will first
1710 recurse into them and update them.
1712 If a remote branch update brings in dependencies on branches
1713 that are not yet instantiated locally, you can either bring in
1714 all the new branches from the remote using ``tg remote
1715 --populate``, or only pick out the missing ones using ``tg create
1716 -r`` (``tg summary`` will point out branches with incomplete
1717 dependencies by showing an ``!`` next to them). TopGit will attempt to
1718 instantiate just the missing ones automatically for you, if possible,
1719 when ``tg update`` merges in the new dependencies from the remote.
1721 Using the alternative ``--base`` mode, ``tg update`` will update
1722 the base of a specified ``[BASE]`` branch (which is a branch created
1723 by ``tg create`` using the ``--base`` option) to the specified
1724 committish (the second argument) and then immediately merge that into
1725 the branch itself using the specified message for the merge commit.
1726 If no message is specified on the command line, an editor will open.
1727 Unless ``--force`` is used the new value for the base must contain
1728 the old value (i.e. be a fast-forward update). This is for safety.
1730 This mode makes updates to ``[BASE]`` branches quick and easy.
1732 | TODO: ``tg update -a -c`` to autoremove (clean) up-to-date branches
1734 tg push
1735 ~~~~~~~
1736 If ``-a`` or ``--all`` was specified, pushes all non-annihilated
1737 TopGit-controlled topic branches, to a remote repository.
1738 Otherwise, pushes the specified topic branches -- or the
1739 current branch, if you don't specify which. By default, the
1740 remote gets all the dependencies (both TopGit-controlled and
1741 non-TopGit-controlled) and bases pushed to it too. If
1742 ``--tgish-only`` was specified, only TopGit-controlled
1743 dependencies will be pushed, and if ``--no-deps`` was specified,
1744 no dependencies at all will be pushed.
1746 The ``--dry-run`` and ``--force`` options are passed directly to
1747 ``git push`` if given.
1749 The remote may be specified with the ``-r`` option. If no remote
1750 was specified, the configured default TopGit remote will be
1751 used.
1753 tg base
1754 ~~~~~~~
1755 Prints the base commit of each of the named topic branches, or
1756 the current branch if no branches are named. Prints an error
1757 message and exits with exit code 1 if the named branch is not
1758 a TopGit branch.
1760 tg log
1761 ~~~~~~
1762 Prints the git log of the named topgit branch -- or the current
1763 branch, if you don't specify a name.
1765 This is really just a convenient shortcut for:
1767 ``git log --first-parent --no-merges $(tg base <name>)..<name>``
1769 where ``<name>`` is the name of the TopGit topic branch (or omitted
1770 for the current branch).
1772 However, if ``<name>`` is a ``[BASE]`` branch the ``--no-merges``
1773 option is omitted.
1775 If ``--compact`` is used then ``git log-compact`` will be used instead
1776 of ``git log``. The ``--command=<git-alias>`` option can be used to
1777 replace "log" with any non-whitespace-containing command alias name,
1778 ``--compact`` is just a shortcut for ``--command=log-compact``. The
1779 ``git-log-compact`` tool may be found on its project page located at:
1781 https://mackyle.github.io/git-log-compact
1783 Note that the ``--compact`` or ``--command=`` option must be used
1784 before any ``--`` or ``git log`` options to be recognized.
1786 NOTE: if you have merged changes from a different repository, this
1787 command might not list all interesting commits.
1789 tg tag
1790 ~~~~~~
1791 Creates a TopGit annotated/signed tag or lists the reflog of one.
1793 A TopGit annotated tag records the current state of one or more TopGit
1794 branches and their dependencies and may be used to revert to the tagged
1795 state at any point in the future.
1797 When reflogs are enabled (the default in a non-bare repository) and
1798 combined with the ``--force`` option a single tag name may be used as a
1799 sort of TopGit branch state stash. The special branch name ``--all``
1800 may be used to tag the state of all current TopGit branches to
1801 facilitate this function and has the side-effect of suppressing the
1802 out-of-date check allowing out-of-date branches to be included.
1804 As a special feature, ``--stash`` may be used as the tag name in which
1805 case ``--all`` is implied if no branch name is listed (instead of the
1806 normal default of ``HEAD``), ``--force`` and ``--no-edit`` (use
1807 ``--edit`` to change that) are automatically activated and the tag will
1808 be saved to ``refs/tgstash`` instead of ``refs/tags/<tagname>``.
1809 The ``--stash`` tag name may also be used with the ``-g``/``--reflog``
1810 option.
1812 The mostly undocumented option ``--allow-outdated`` will bypass the
1813 out-of-date check and is implied when ``--stash`` or ``--all`` is used.
1815 A TopGit annotated/signed tag is simply a Git annotated/signed tag with
1816 a "TOPGIT REFS" section appended to the end of the tag message (and
1817 preceding the signature for signed tags). PEM-style begin and end
1818 lines surround one line per ref where the format of each line is
1819 full-hash SP ref-name. A line will be included for each branch given
1820 on the command line and each ref they depend on either directly or
1821 indirectly.
1823 If more than one TopGit branch is given on the command line, a new
1824 commit will be created that has an empty tree and all of the given
1825 TopGit branches as parents and that commit will be tagged. If a single
1826 TopGit branch is given, then it will be tagged. If the ``--tree``
1827 option is used then it will be used instead of an empty tree (a new
1828 commit will be created if necessary to guarantee the specified tree is
1829 what's in the commit the newly created tag refers to). The argument to
1830 the ``--tree`` option may be any valid treeish.
1832 If exactly one of the branches to be tagged is prefixed with a tilde
1833 (``~``) it will be made the first parent of a consolidation commit if
1834 it is not already the sole commit needing to be tagged. If ``--tree``
1835 is NOT used, its tree will also be used instead of the empty tree for
1836 any new consolidation commit if one is created. Note that if
1837 ``--tree`` is given explicitly it's tree is always used but that does
1838 not in any way affect the choice of first parent. Beware that the
1839 ``~`` may need to be quoted to prevent the shell from misinterpreting
1840 it into something else.
1842 All the options for creating a tag serve the same purpose as their Git
1843 equivalents except for two. The ``--refs`` option suppresses tag
1844 creation entirely and emits the "TOPGIT REFS" section that would have
1845 been included with the tag. If the ``--no-edit`` option is given and
1846 no message is supplied (via the ``-m`` or ``-F`` option) then the
1847 default message created by TopGit will be used without running the
1848 editor.
1850 With ``-g`` or ``--reflog`` show the reflog for a tag. With the
1851 ``--reflog-message`` option the message from the reflog is shown.
1852 With the ``--commit-message`` option the first line of the tag's
1853 message (if the object is a tag) or the commit message (if the object
1854 is a commit) falling back to the reflog message for tree and blob
1855 objects is shown. The default is ``--reflog-message`` unless the
1856 ``--stash`` (``refs/tgstash``) is being shown in which case the default
1857 is then ``--commit-message``. Just add either option explicitly to
1858 override the default.
1860 When showing reflogs, non-tag entries are annotated with their type
1861 unless ``--no-type`` is given.
1863 TopGit tags are created with a reflog if core.logallrefupdates is
1864 enabled (the default for non-bare repositories). Unfortunately Git
1865 is incapable of showing an annotated/signed tag's reflog
1866 (using git log -g) as it will first resolve the tag before checking to
1867 see if it has a reflog. Git can, however, show reflogs for lightweight
1868 tags (using git log -g) just fine but that's not helpful here. Use
1869 ``tg tag`` with the ``-g`` or ``--reflog`` option to see the reflog for
1870 an actual tag object. This also works on non-TopGit annotated/signed
1871 tags as well provided they have a reflog.
1873 The number of entries shown may be limited with the ``-n`` option. If
1874 the tagname is omitted then ``--stash`` is assumed.
1876 The ``--delete`` option is a convenience option that runs the
1877 ``git update-ref -d`` command on the specified tag removing it and its
1878 reflog (if it has one).
1880 The ``--clear`` option clears all but the most recent (the ``@{0}``)
1881 reflog entries from the reflog for the specified tag. It's equivalent
1882 to dropping all the higher numbered reflog entries.
1884 The ``--drop`` option drops the specified reflog entry and requires the
1885 given tagname to have an ``@{n}`` suffix where ``n`` is the reflog
1886 entry number to be dropped. This is really just a convenience option
1887 that runs the appropriate ``git reflog delete`` command.
1889 Note that when combined with ``tg revert``, a tag created by ``tg tag``
1890 can be used to transfer TopGit branches. Simply create the tag, push
1891 it somewhere and then have the recipient run ``tg revert`` to recreate
1892 the TopGit branches. This may be helpful in situations where it's not
1893 feasible to push all the refs corresponding to the TopGit-controlled
1894 branches and their top-bases.
1896 tg rebase
1897 ~~~~~~~~~
1898 Provides a ``git rebase`` rerere auto continue function. It may be
1899 used as a drop-in replacement front-end for ``git rebase -m`` that
1900 automatically continues the rebase when ``git rerere`` information is
1901 sufficient to resolve all conflicts.
1903 You have enabled ``git rerere`` haven't you?
1905 If the ``-m`` or ``--merge`` option is not present then ``tg rebase``
1906 will complain and not do anything.
1908 When ``git rerere`` is enabled, previously resolved conflicts are
1909 remembered and can be automatically staged (see ``rerere.autoUpdate``).
1911 However, even with auto staging, ``git rebase`` still stops and
1912 requires an explicit ``git rebase --continue`` to keep going.
1914 In the case where ``git rebase -m`` is being used to flatten history
1915 (such as after a ``tg export --collapse`` prior to a
1916 ``git format-patch``), there's a good chance all conflicts have already
1917 been resolved during normal merge maintenance operations so there's no
1918 reason ``git rebase`` could not automatically continue, but there's no
1919 option to make it do so.
1921 The ``tg rebase`` command provides a ``git rebase --auto-continue``
1922 function.
1924 All the same rebase options can be used (they are simply passed through
1925 to Git unchanged). However, the ``rerere.autoUpdate`` option is
1926 automatically temporarily enabled while running ``git rebase`` and
1927 should ``git rebase`` stop asking one to resolve and continue, but all
1928 conflicts have already been resolved and staged using rerere
1929 information, then ``git rebase --continue`` will be automatically run.
1931 tg revert
1932 ~~~~~~~~~
1933 Provides the ability to revert one or more TopGit branches and their
1934 dependencies to a previous state contained within a tag created using
1935 the ``tg tag`` command. In addition to the actual revert mode
1936 operation a list mode operation is also provided to examine a tag's ref
1937 contents.
1939 The default mode (``-l`` or ``--list``) shows the state of one or more
1940 of the refs/branches stored in the tag data. When no refs are given on
1941 the command line, all refs in the tag data are shown. With the special
1942 ref name ``--heads`` then the indepedent heads contained in the tag
1943 data are shown. The ``--deps`` option shows the specified refs and all
1944 of their dependencies in a single list with no duplicates. The
1945 ``--rdeps`` option shows a display similar to ``tg summary --rdeps``
1946 for each ref or all TopGit heads if no ref is given on the command
1947 line. The standard ``--no-short``, ``--short=n`` etc. options may be
1948 used to override the default ``--short`` output. With ``--hash`` (or
1949 ``--hash-only``) show only the hash in ``--list`` mode in which case
1950 the default is ``--no-short``. The ``--hash`` option can be used much
1951 like the ``git rev-parse --verify`` command to extract a specific hash
1952 value out of a TopGit tag.
1954 Note that unlike `tg summary`_, here ``--heads`` actually does mean the
1955 ``git merge-base --independent`` heads of the stored refs from the tag
1956 data. To see only the independent TopGit topic branch heads stored in
1957 the tag data use the ``--topgit-heads`` option instead. The default
1958 for the ``--rdeps`` option is ``--topgit-heads`` but ``--heads`` can
1959 be given explicitly to change that. (Note that ``--heads-independent``
1960 is accepted as an alias for ``--heads`` as well.)
1962 The revert mode has three submodes, dry-run mode (``-n`` or
1963 ``--dry-run``), force mode (``-f`` or ``--force``) and interactive mode
1964 (``-i`` or ``--interactive``). If ``--dry-run`` (or ``-n``) is given
1965 no ref updates will actually be performed but what would have been
1966 updated is shown instead. If ``--interactive`` (or ``-i``) is given
1967 then the editor is invoked on an instruction sheet allowing manual
1968 selection of the refs to be updated before proceeding. Since revert is
1969 potentially a destructive operation, at least one of the submodes must
1970 be specified explicitly. If no refs are listed on the command line
1971 then all refs in the tag data are reverted. Otherwise the listed refs
1972 and all of their dependencies (unless ``--no-deps`` is given) are
1973 reverted. Unless ``--no-stash`` is given a new stash will be created
1974 using ``tg tag --stash`` (except, of course, in dry-run mode) just
1975 before actually performing the updates to facilitate recovery from
1976 accidents.
1978 Both modes accept fully-qualified (i.e. starts with ``refs/``) ref
1979 names as well as unqualified names (which will be assumed to be located
1980 under ``refs/heads/``). In revert mode a tgish ref will always have
1981 both its ``refs/heads/`` and ``refs/top-bases/`` values included no
1982 matter how it's listed unless ``--no-deps`` is given and the ref is
1983 fully qualified (i.e. starts with ``refs/``) or one or the other of its
1984 values was removed from the instruction sheet in interactive mode. In
1985 list mode a tgish ref will always have both its ``refs/heads/`` and
1986 ``refs/top-bases/`` values included only when using the ``--deps`` or
1987 ``--rdeps`` options.
1989 The ``--tgish-only`` option excludes non-tgish refs (i.e. refs that do
1990 not have a ``refs/heads/<name>``, ``refs/top-bases/<name>`` pair).
1992 The ``--exclude`` option (which can be repeated) excludes specific
1993 refs. If the name given to ``--exclude`` is not fully-qualified (i.e.
1994 starts with ``refs/``) then it will exclude both members of a tgish ref
1995 pair.
1997 The ``--quiet`` (or ``-q``) option may be used in revert mode to
1998 suppress non-dry-run ref change status messages.
2000 The special tag name ``--stash`` (as well as with ``@{n}`` suffixes)
2001 can be used to refer to ``refs/tgstash``.
2003 The ``tg revert`` command supports tags of tags that contains TopGit
2004 refs. So, for example, if you do this::
2006 tg tag newtag --all
2007 git tag -f -a -m "tag the tag" newtag newtag
2009 Then ``newtag`` will be a tag of a tag containing a ``TOPGIT REFS``
2010 section. ``tg revert`` knows how to dereference the outermost
2011 tag to get to the next (and the next etc.) tag to find the
2012 ``TOPGIT REFS`` section so after the above sequence, the tag ``newtag``
2013 can still be used successfully with ``tg revert``.
2015 NOTE: If HEAD points to a ref that is updated by a revert operation
2016 then NO WARNING whatsoever will be issued, but the index and working
2017 tree will always be left completely untouched (and the reflog for
2018 the pointed-to ref can always be used to find the previous value).
2020 tg prev
2021 ~~~~~~~
2022 Output the "previous" branch(es) in the patch series containing the
2023 current or named branch. The "previous" branch(es) being one step
2024 away by default.
2026 Options:
2027 -i show dependencies based on index instead of branch
2028 -w show dependencies based on working tree instead of branch
2029 -n <steps> take ``<steps>`` "previous" steps (default 1)
2030 --all take as many "previous" steps as possible (aka ``-a``)
2031 --verbose show containing series name(s) (aka ``-v``)
2033 The ``-n`` option may also be given as ``--count`` or ``--count=<n>``.
2035 To list all dependencies of a branch see the ``--deps`` option of
2036 the `tg info`_ command.
2038 See also NAVIGATION_ for full details on "previous" steps.
2040 tg next
2041 ~~~~~~~
2042 Output tne "next" branch(es) in the patch series containing the current
2043 or named branch. The "next" branch(es) being one step away by default.
2045 Options:
2046 -i show dependencies based on index instead of branch
2047 -w show dependencies based on working tree instead of branch
2048 -n <steps> take ``<steps>`` "next" steps (default 1)
2049 --all take as many "next" steps as possible (aka ``-a``)
2050 --verbose show containing series name(s) (aka ``-v``)
2052 The ``-n`` option may also be given as ``--count`` or ``--count=<n>``.
2054 To list all dependents of a branch see the ``--dependents`` option of
2055 the `tg info`_ command.
2057 See also NAVIGATION_ for full details on "next" steps.
2059 tg migrate-bases
2060 ~~~~~~~~~~~~~~~~
2061 Transition top-bases from old location to new location.
2063 Beginning with TopGit release 0.19.4, TopGit has the ability to store
2064 the top-bases refs in either the old ``ref/top-bases/...`` location or
2065 the new ``refs/heads/{top-bases}/...`` location. Starting with TopGit
2066 release 0.20.0, the default is the new location.
2068 By storing the top-bases under heads, Git is less likely to complain
2069 when manipulating them, hosting providers are more likely to provide
2070 access to them and Git prevents them from pointing at anything other
2071 than a commit object. All in all a win for everyone.
2073 TopGit attempts to automatically detect whether the new or old location
2074 is being used for the top-bases and just do the right thing. However,
2075 by explicitly setting the config value ``topgit.top-bases`` to either
2076 ``refs`` for the old location or ``heads`` for the new location the
2077 auto-detection can be bypassed. If no top-bases refs are present in
2078 the repository the default prior to TopGit release 0.20.0 is to use the
2079 old location but starting with TopGit release 0.20.0 the default is to
2080 use the new location.
2082 The ``tg migrate-bases`` command may be used to migrate top-bases refs
2083 from the old location to the new location (or, by using the
2084 undocumented ``--reverse`` option, vice versa).
2086 With few exceptions (``tg create -r`` and ``tg revert``), all top-bases
2087 refs (both local *and* remote refs) are expected to be stored in the
2088 same location (either new or old). A repository's current location for
2089 storing top-bases refs may be shown with the ``tg --top-bases`` command.
2091 TODO: tg rename
2092 ~~~~~~~~~~~~~~~
2094 IMPLEMENTATION
2095 --------------
2097 TopGit stores all the topic branches in the regular ``refs/heads/``
2098 namespace (so we recommend distinguishing them with the ``t/`` prefix).
2099 Apart from that, TopGit also maintains a set of auxiliary refs in
2100 ``refs/top-*``. Currently, only ``refs/top-bases/`` is used, containing the
2101 current *base* of the given topic branch -- this is basically a merge of
2102 all the branches the topic branch depends on; it is updated during ``tg
2103 update`` and then merged to the topic branch, and it is the base of a
2104 patch generated from the topic branch by ``tg patch``.
2106 All the metadata is tracked within the source tree and history of the
2107 topic branch itself, in ``.top*`` files; these files are kept isolated
2108 within the topic branches during TopGit-controlled merges and are of
2109 course omitted during ``tg patch``. The state of these files in base
2110 commits is undefined; look at them only in the topic branches
2111 themselves. Currently, two files are defined:
2113 ``.topmsg``:
2114 Contains the description of the topic branch in a
2115 mail-like format, plus the author information, whatever
2116 Cc headers you choose or the post-three-dashes message.
2117 When mailing out your patch, basically only a few extra
2118 mail headers are inserted and then the patch itself is
2119 appended. Thus, as your patches evolve, you can record
2120 nuances like whether the particular patch should have
2121 To-list / Cc-maintainer or vice-versa and similar
2122 nuances, if your project is into that. ``From`` is
2123 prefilled from your current ``GIT_AUTHOR_IDENT``; other
2124 headers can be prefilled from various optional
2125 ``topgit.*`` git config options.
2127 ``.topdeps``:
2128 Contains the one-per-line list of branches this branch
2129 depends on, pre-seeded by ``tg create``. A (continuously
2130 updated) merge of these branches will be the *base* of
2131 your topic branch.
2133 IMPORTANT: DO NOT EDIT ``.topdeps`` MANUALLY!!! If you do so, you need to
2134 know exactly what you are doing, since this file must stay in sync with
2135 the Git history information, otherwise very bad things will happen.
2137 TopGit also automagically installs a bunch of custom commit-related
2138 hooks that will verify whether you are committing the ``.top*`` files in a
2139 sane state. It will add the hooks to separate files within the ``hooks/``
2140 subdirectory, and merely insert calls to them to the appropriate hooks
2141 and make them executable (but will make sure the original hook's code is
2142 not called if the hook was not executable beforehand).
2144 Another automagically installed piece is a ``.git/info/attributes``
2145 specifier for an ``ours`` merge strategy for the files ``.topmsg`` and
2146 ``.topdeps``, and the (intuitive) ``ours`` merge strategy definition in
2147 ``.git/config``.
2150 REMOTE HANDLING
2151 ---------------
2153 There are two remaining issues with accessing topic branches in remote
2154 repositories:
2156 (i) Referring to remote topic branches from your local repository
2157 (ii) Developing some of the remote topic branches locally
2159 There are two somewhat contradictory design considerations here:
2161 (a) Hacking on multiple independent TopGit remotes in a single
2162 repository
2163 (b) Having a self-contained topic system in local refs space
2165 To us, (a) does not appear to be very convincing, while (b) is quite
2166 desirable for ``git-log topic`` etc. working, and increased conceptual
2167 simplicity.
2169 Thus, we choose to instantiate all the topic branches of given remote
2170 locally; this is performed by ``tg remote --populate``. ``tg update``
2171 will also check if a branch can be updated from its corresponding remote
2172 branch. The logic needs to be somewhat involved if we are to "do the
2173 right thing". First, we update the base, handling the remote branch as
2174 if it was the first dependency; thus, conflict resolutions made in the
2175 remote branch will be carried over to our local base automagically.
2176 Then, the base is merged into the remote branch and the result is merged
2177 to the local branch -- again, to carry over remote conflict resolutions.
2178 In the future, this order might be adjustable on a per-update basis, in
2179 case local changes happen to be diverging more than the remote ones.
2180 (See the details in `The Update Process`_ for more in depth coverage.)
2182 All commands by default refer to the remote that ``tg remote --populate``
2183 was called on the last time (stored in the ``topgit.remote`` git
2184 configuration variable). You can manually run any command with a
2185 different base remote by passing ``-r REMOTE`` *before* the subcommand
2186 name or passing ``-u`` *before* the subcommand to run without one.
2189 TESTING TOPGIT
2190 --------------
2192 Running the TopGit test suite only requires POSIX compatibile utilities (just
2193 a POSIX compatibile ``make`` will do) AND a ``perl`` binary.
2195 It is *not* necessary to install TopGit in order to run the TopGit test suite.
2197 To run the TopGit test suite, simply execute this from the top-level of a
2198 TopGit checkout or expanded release tarball:
2200 ::
2202 make test
2204 Yup, that's it. But you're probably thinking, "Why have a whole section just
2205 to say 'run make test'?" Am I right?
2207 The simple ``make test`` command produces a lot of output and while it is
2208 summarized at the end there's a better way.
2210 Do you have the ``prove`` utility available? You need ``perl`` to run the
2211 tests and ``prove`` comes with ``perl`` so you almost cerainly do.
2213 Try running the tests like so:
2215 ::
2217 make DEFAULT_TEST_TARGET=prove test
2220 (For reference, the default value of ``DEFAULT_TEST_TARGET`` is ``test`` which
2221 can be used to override a setting that's been altered using the instructions
2222 shown later on below.)
2224 If that works (you can interrupt it with ``Ctrl-C``), try this next:
2226 ::
2228 make DEFAULT_TEST_TARGET=prove TESTLIB_PROVE_OPTS="-j 4 --timer" test
2230 If that one works (again, you can interrupt it with ``Ctrl-C``) that may end
2231 up being the keeper for running the tests.
2233 However, if you don't have ``prove`` for some reason even though you do have
2234 ``perl``, there's still an alternative for briefer output. Try this:
2236 ::
2238 make TESTLIB_TEST_OPTS=-q test
2240 Much of the normal testing output will be suppressed and there's still a
2241 summary at the end. If you're stuck with this version but your make supports
2242 parallel operation (the ``-j`` *<n>*) option, then you might try this:
2244 ::
2246 make -j 4 TESTLIB_TEST_OPTS=-q test
2248 If your make *does* support the parallel ``-j`` option but still seems to be
2249 only running one test at a time try it like this instead:
2251 ::
2253 make TESTLIB_MAKE_OPTS="-j 4" TESTLIB_TEST_OPTS=-q test
2255 The difference is that ``make -j 4`` relies on make to properly pass down the
2256 parallel job option all the way down to the sub-make that runs the individual
2257 tests when not using prove. Putting the options in ``TESTLIB_MAKE_OPTS``
2258 passes them directly to that (and only that) particular invocation of make.
2260 The final bit of advice for running the tests is that any of those ``make``
2261 variable settings can be enabled by default in a top-level ``config.mak`` file.
2263 For example, to make the ``prove -j 4 --timer`` (my personal favorite) the
2264 default when running the tests, add these lines (creating the file if it does
2265 not already exist) to the ``config.mak`` file located in the top-level of the
2266 TopGit checkout (or expanded release tarball):
2268 ::
2270 # config.mak file
2271 # comments are allowed (if preceded by '#')
2272 # so are blank lines
2274 DEFAULT_TEST_TARGET = prove
2275 TESTLIB_PROVE_OPTS = -j 4 --timer
2276 #TESTLIB_TEST_OPTS = --color # force colorized test output
2278 Now simply doing ``make test`` will use those options by default.
2280 There is copious documentation on the testing library and other options in
2281 the various ``README`` files located in the ``t`` subdirectory. The
2282 ``Makefile.mak`` file in the ``t`` subdirectory contains plenty of comments
2283 about possible makefile variable settings as well.
2287 TECHNICAL
2288 ---------
2290 A familiarity with the terms in the GLOSSARY_ is helpful for understanding the
2291 content of this sections. See also the IMPLEMENTATION_ section.
2293 The Update Process
2294 ~~~~~~~~~~~~~~~~~~
2296 When a branch is "updated" using the ``tg update`` command the following steps
2297 are taken:
2299 1) The branch and all of its dependencies (and theirs recursively)
2300 are checked to see which ones are *out-of-date*. See glossary_.
2302 2) Each of the branch's direct dependencies (i.e. they are listed in
2303 the branch's ``.topdeps`` file) which is out of date is updated
2304 before proceeding (yup, this is a recursive process).
2306 3) Each of the branch's direct dependencies (i.e. they are listed in
2307 the branch's ``.topdes`` file) that was updated in the previous
2308 step is now merged into the branch's corresponding base. If a
2309 remote is involved, and the branch's corresponding base does NOT
2310 contain the remote branch's corresponding base that remote base is
2311 also merged into the branch's base at this time as well (it will be
2312 the first item merged into the branch's base).
2314 4) If the branch has a corresponding remote branch and the branch
2315 does not already contain it, it's merged into the branch's base
2316 (which was possibly already updated in step (3) to contain the
2317 remote branch's base but not the remote branch itself) on a detached
2318 HEAD. Yup, this step can be a bit confusing and no, the updated
2319 base from step (3) has not yet been merged into the branch itself
2320 yet either. If there is no remote branch this step does not apply.
2321 Using a detached HEAD allows the remote branch to be merged into the
2322 contents of the base without actually perturbing the base's ref.
2324 5) If there is a remote branch present then use the result of step (4)
2325 otherwise use the branch's base and merge that into the branch
2326 itself.
2328 That's it! Simple, right? ;)
2330 Unless the auto stash option has been disabled (see `no undo`_, `tg update`_
2331 and `tg tag`_), a copy of all the old refs values will be stashed away
2332 immediately after step (1) before starting step (2), but only if anything is
2333 actually found to be out-of-date.
2335 Merge Strategies
2336 ~~~~~~~~~~~~~~~~
2338 The ``tg update`` command regularly performs merges while executing an update
2339 operation. In order to speed things up, it attempts to do in-index merges
2340 where possible. It accomplishes this by using a separate, temporary index
2341 file and the ``git read-tree -m --aggressive`` command possibly assisted by
2342 the ``git merge-index`` and ``git merge-file`` commands. This combination may
2343 be repeated more than once to perform an octopus in-index merge. If this
2344 fails, the files are checked out and a normal ``git merge`` three-way merge is
2345 performed (possily multiple times). If the normal ``git merge`` fails then
2346 user intervention is required to resolve the merge conflict(s) and continue.
2348 Since the ``tg annihilate``, ``tg create`` and ``tg depend add`` commands may
2349 end up running the ``tg update`` machinery behind the scenes to complete their
2350 operation they may also result in any of these merge strategies being used.
2352 In addition to the normal Git merge strategies (if the in-index merging fails),
2353 there are four possible TopGit merge strategies that may be shown. Since they
2354 all involve use of the ``git read-tree -m --aggressive`` command they are all
2355 variations of a "trivial aggressive" merge. The "trivial" part because all of
2356 the merges done by ``git read-tree -m`` are described as "trivial" and the
2357 "aggressive" part because the ``--aggressive`` option is always used.
2359 1) "trivial aggressive"
2360 Only two heads were involved and all merging was completed by
2361 the ``git read-tree -m --aggressive`` command.
2363 2) "trivial aggressive automatic"
2364 Only two heads were involved but after the
2365 ``git read-tree -m --aggressive`` command completed there were
2366 still unresolved items and ``git merge-index`` had to be run
2367 (using the ``tg index-merge-one-file`` driver) which ultimately
2368 ran ``git merge-file`` at least once to perform a simple
2369 automatic three-way merge. Hence the "automatic" description
2370 and the "Auto-merging ..." output line(s).
2372 3) "trivial aggressive octopus"
2373 This is the same as a "trivial aggressive" merge except that
2374 more than two heads were involved and after merging the first
2375 two heads, the ``git read-tree -m --aggressive`` step was
2376 repeated again on the result for each additional head. All
2377 merging was completed via multiple
2378 ``git read-tree -m --aggressive`` commands only.
2379 This beast is relatively rare in the wild.
2381 4) "trivial aggressive automatic octopus"
2382 This is very similar to the "trivial aggressive octopus"
2383 except that at least one of the ``git read-tree -m --aggressive``
2384 commands left unresolved items that were handled the same way
2385 as the "trivial aggressive automatic" strategy. This species
2386 is commonly seen in the wild.
2389 GLOSSARY
2390 --------
2392 .topmsg
2393 Version-controlled file stored at the root level of each
2394 TopGit branch that contains the patch header for a TopGit
2395 branch. See also IMPLEMENTATION_;
2397 .topdeps
2398 Version-controlled file stored at the root level of each
2399 TopGit branch that lists the branch's dependencies one per
2400 line omitting the leading ``refs/heads/`` part. See also
2401 IMPLEMENTATION_;
2403 branch containment
2404 Given two Git commit identifiers (e.g. hashes) C1 and C2,
2405 commit C1 "contains" commit C2 if either they are the same
2406 commit or C2 can be reached from C1 by following one or more
2407 parent links from C1 (perhaps via one or more intermediate
2408 commits along the way). In other words, if C1 contains C2
2409 then C2 is an ancestor of C1 or conversely C1 is a descendant
2410 of C2. Since a TopGit branch name is also the name of a Git
2411 branch (something located under the ``refs/heads`` Git
2412 namespace) and similarly for a TopGit base, they can both be
2413 resolved to a Git commit identifier and then participate in
2414 a branch containment test. An easy mnemonic for this is
2415 "children contain the genes of their parents."
2417 BRE pattern
2418 A Basic Regular Expression (BRE) pattern. These are older
2419 style regular expressions but have the advantage that all
2420 characters other than ``\``, ``.``, ``*`` and ``[``
2421 automatically match themselves without need for backslash
2422 quoting (well actually, ``^`` and ``$`` are special at the
2423 beginning and end respectively but otherwise match themselves).
2425 contains
2426 See branch containment.
2428 ERE pattern
2429 An Extended Regular Expression (ERE) pattern. These are newer
2430 style regular expressions where all the regular expression
2431 "operator" characters "operate" when NOT preceded by a
2432 backslash and are turned into normal characters with a ``\``.
2433 The backreference atom, however, may not work, but ``?``, ``+``
2434 and ``|`` "operators" do; unlike BREs.
2436 TopGit
2437 Excellent system for managing a history of changes to one
2438 or more possibly interrelated patches.
2440 TopGit branch
2441 A Git branch that has an associated TopGit base. Conceptually
2442 it represents a single patch that is the difference between
2443 the associated TopGit base and the TopGit branch. In other
2444 words ``git diff-tree <TopGit base> <TopGit branch>`` except
2445 that any ``.topdeps`` and/or ``.topmsg`` files are excluded
2446 from the result and the contents of the ``.topmsg`` file from
2447 the TopGit branch is prefixed to the result.
2449 TopGit bare branch
2450 A Git branch whose tree does NOT contain any `.topdeps` or
2451 `.topmsg` entries at the top-level of the tree. It *does*
2452 always have an associated "TopGit base" ref (otherwise it would
2453 not be a "TopGit" branch). See also `BARE BRANCHES`_.
2455 bare branch
2456 In TopGit context, "bare branch" almost always refers to a
2457 "TopGit bare branch" and should be understood to mean such even
2458 if the leading "TopGit" has been left off.
2460 TopGit base
2461 A Git branch that records the base upon which a TopGit branch's
2462 single conceptual "patch" is built. The name of the Git branch
2463 is derived from the TopGit branch name by stripping off the
2464 leading ``refs/heads/`` and appending the correct prefix where
2465 all TopGit bases are stored (typically either
2466 ``refs/top-bases/`` or ``refs/heads/{top-bases}/`` -- the
2467 prefix for any given repository can be shown by using the
2468 ``tg --top-bases`` command and updated using the
2469 ``tg migrate-bases`` command).
2471 All of a TopGit branch's dependencies are merged into the
2472 corresponding TopGit base during a ``tg update`` of a branch.
2474 base
2475 See TopGit base.
2477 TopGit ``[PATCH]`` branch
2478 A TopGit branch whose subject starts with ``[PATCH]``. By
2479 convention these TopGit branches contain a single patch
2480 (equivalent to a single patch file) and have at least one
2481 dependency (i.e. their ``.topdeps`` files are never empty).
2483 TopGit ``[BASE]`` branch
2484 A TopGit branch whose subject starts with ``[BASE]``. By
2485 convention these TopGit branches do not actually contain
2486 any changes and their ``.topdeps`` files are empty. They
2487 are used to control a base dependency that another set of
2488 branches depends on.
2490 TopGit ``[STAGE]`` branch
2491 A TopGit branch whose subject starts with ``[STAGE]``. By
2492 convention these TopGit branches do not actually contain any
2493 changes of their own but do have one or (typically) more
2494 dependencies in their ``.topdeps`` file. These branches are
2495 used to bring together one or (typically) more independent
2496 TopGit ``[PATCH]`` branches into a single branch so that
2497 testing and/or evaluation can be performed on the result.
2499 merge conflict
2500 When merging two (or more) heads that touch the same lines in
2501 the file but in different ways the result is a merge conflict
2502 that requires manual intervention. If a merge conflict occurs
2503 with more than two heads (an octopus merge) it's generally
2504 replaced by multiple three-way merges so that by the time a
2505 user sees a merge conflict needing manual resolution, there
2506 will be only two heads involved.
2508 merge strategy
2509 A Git merge strategy (see the "MERGE STRATEGIES" section of
2510 ``git help merge``) or one of the TopGit `merge strategies`_
2511 used to merge two or more heads.
2513 TopGit merge strategy
2514 See the `Merge Strategies`_ section above for details but
2515 basically these are just in-index merges done using the
2516 ``git read-tree -m --aggressive`` command one or more times
2517 possibily assisted by the ``git merge-index`` and the
2518 ``git merge-file`` commands.
2520 next branch
2521 In TopGit context the "next" branch refers to the branch that
2522 corresponds to the next (aka following) patch in an ordered
2523 (aka linearized) list of patches created by exporting the
2524 TopGit branches in patch application order.
2526 octopus merge
2527 A merge involving more than two heads. Note that if there are
2528 less than three independent heads the resulting merge that
2529 started out as an octopus will end up not actually being an
2530 octopus after all.
2532 out-of-date branch
2533 A TopGit branch is considered to be "out-of-date" when ANY of
2534 the following are true:
2536 a) The TopGit branch does NOT contain its
2537 corresponding base.
2539 b) The TopGit branch does NOT contain its
2540 corresponding remote branch (there may not be
2541 a remote branch in which case this does not apply)
2543 c) The TopGit branch's base does NOT contain its
2544 corresponding remote branch's base (there may not be
2545 a remote branch in which case this does not apply)
2547 d) Any of the TopGit branches listed in the branch's
2548 ``.topdeps`` file are NOT contained by the branch.
2549 (See "branch containment" above.)
2551 e) Any of the TopGit branches listed in the branch's
2552 ``.topdeps`` file are out-of-date.
2554 Note that if a remote branch is present and is NOT out-of-date
2555 then it will contain its own base and (c) is mostly redundant.
2557 previous branch
2558 In TopGit context the "previous" (or "prev") branch refers to
2559 the branch that corresponds to the previous (aka preceding)
2560 patch in an ordered (aka linearized) list of patches created by
2561 exporting the TopGit branches in patch application order.
2563 remote TopGit branch
2564 A Git branch with the same branch name as a TopGit branch
2565 but living under ``refs/remotes/<some remote>/`` instead
2566 of just ``refs/heads/``.
2568 remote TopGit base
2569 The TopGit base branch corresponding to a remote TopGit branch,
2570 which lives under ``refs/remotes/`` somewhere (depending on
2571 what the output of ``tg --top-bases`` is for that remote).
2573 three-way merge
2574 A three-way merge takes a common base and two heads (call them
2575 A and B) and creates a new file that is the common base plus
2576 all of the changes made between the common base and head A
2577 *AND* all of the changes made between the common base and
2578 head B. The technique used to accomplish this is called a
2579 "merge strategy".
2582 REFERENCES
2583 ----------
2585 The following references are useful to understand the development of
2586 topgit and its subcommands.
2588 * tg depend:
2589 http://public-inbox.org/git/36ca99e90904091034m4d4d31dct78acb333612e678@mail.gmail.com/T/#u
2592 THIRD-PARTY SOFTWARE
2593 --------------------
2595 The following software understands TopGit branches:
2597 * `magit <http://magit.github.io/>`_ -- a git mode for emacs
2599 IMPORTANT: Magit requires its topgit mode to be enabled first, as
2600 described in its documentation, in the "Activating extensions"
2601 subsection. If this is not done, it will not push TopGit branches
2602 correctly, so it's important to enable it even if you plan to mostly use
2603 TopGit from the command line.