| blob | f8f8d2115fd794e89b17d83c44891c76448529fa |
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 :USAGE_: Command Line details
20 :`NO UNDO`_: Where's the undo!!!
21 :CONVENTIONS_: Suggestions for organizing your TopGit branches
22 :`EXTRA SETTINGS`_: Various possible "topgit.*" config settings
23 :ALIASES_: Git-like TopGit command aliases
24 :GLOSSARY_: All the TopGit vocabulary in one place
25 :TECHNICAL_: How it works behind the scenes
28 REQUIREMENTS
29 ------------
31 TopGit is a collection of POSIX shell scripts so a POSIX-compliant shell is
32 required along with some standard POSIX-compliant utilities (e.g. sed, awk,
33 cat, etc.). Git version 1.8.5 or later is also required.
35 To use TopGit with linked working trees (the ``git worktree add`` command),
36 at least Git version 2.5.0 (obviously, since that's when the ``git worktree``
37 command first appeared) is needed in which case linked working trees are then
38 fully supported for use with TopGit.
40 The scripts need to be preprocessed and installed and currently the Makefile
41 that does this requires GNU make, but that's an install-time-only requirement.
43 It is possible, however, to use the DESTDIR functionality to install TopGit to
44 a staging area on one machine, archive that and then unarchive it on another
45 machine to perform an install (provided the build prefix and other options are
46 compatible with the final installed location).
49 INSTALLATION
50 ------------
52 See the file ``INSTALL``.
55 GIT REPOSITORY
56 --------------
58 The TopGit git repository can be found at <http://repo.or.cz/topgit/pro>.
61 RATIONALE
62 ---------
64 Why not use something like StGIT or Guilt or ``rebase -i`` for maintaining
65 your patch queue? The advantage of these tools is their simplicity;
66 they work with patch *series* and defer to the reflog facility for
67 version control of patches (reordering of patches is not
68 version-controlled at all). But there are several disadvantages -- for
69 one, these tools (especially StGIT) do not actually fit well with plain
70 Git at all: it is basically impossible to take advantage of the index
71 effectively when using StGIT. But more importantly, these tools
72 horribly fail in the face of a distributed environment.
74 TopGit has been designed around three main tenets:
76 (i) TopGit is as thin a layer on top of Git as possible. You
77 still maintain your index and commit using Git; TopGit will only
78 automate a few indispensable tasks.
80 (ii) TopGit is anxious about *keeping* your history. It will
81 never rewrite your history, and all metadata is also tracked
82 by Git, smoothly and non-obnoxiously. It is good to have a
83 *single* point when the history is cleaned up, and that is at
84 the point of inclusion in the upstream project; locally, you
85 can see how your patch has evolved and easily return to older
86 versions.
88 (iii) TopGit is specifically designed to work in a
89 distributed environment. You can have several instances of
90 TopGit-aware repositories and smoothly keep them all
91 up-to-date and transfer your changes between them.
93 As mentioned above, the main intended use-case for TopGit is tracking
94 third-party patches, where each patch is effectively a single topic
95 branch. In order to flexibly accommodate even complex scenarios when
96 you track many patches where many are independent but some depend on
97 others, TopGit ignores the ancient Quilt heritage of patch series and
98 instead allows the patches to freely form graphs (DAGs just like Git
99 history itself, only "one level higher"). For now, you have to manually
100 specify which patches the current one depends on, but TopGit might help
101 you with that in the future in a darcs-like fashion.
103 A glossary_ plug: The union (i.e. merge) of patch dependencies is called
104 a *base* of the patch (topic branch).
106 Of course, TopGit is perhaps not the right tool for you:
108 (i) TopGit is not complicated, but StGIT et al. are somewhat
109 simpler, conceptually. If you just want to make a linear
110 purely-local patch queue, deferring to StGIT instead might
111 make more sense.
113 (ii) When using TopGit, your history can get a little hairy
114 over time, especially with all the merges rippling through.
115 ;-)
118 SYNOPSIS
119 --------
121 ::
123 ## Create and evolve a topic branch
124 $ tg create t/gitweb/pathinfo-action
125 tg: Automatically marking dependency on master
126 tg: Creating t/gitweb/pathinfo-action base from master...
127 $ ..hack..
128 $ git commit
129 $ ..fix a mistake..
130 $ git commit
132 ## Create another topic branch on top of the former one
133 $ tg create t/gitweb/nifty-links
134 tg: Automatically marking dependency on t/gitweb/pathinfo-action
135 tg: Creating t/gitweb/nifty-links base from t/gitweb/pathinfo-action...
136 $ ..hack..
137 $ git commit
139 ## Create another topic branch on top of master and submit
140 ## the resulting patch upstream
141 $ tg create t/revlist/author-fixed master
142 tg: Creating t/revlist/author-fixed base from master...
143 $ ..hack..
144 $ git commit
145 $ tg patch -m
146 tg: Sent t/revlist/author-fixed
147 From: pasky@suse.cz
148 To: git@vger.kernel.org
149 Cc: gitster@pobox.com
150 Subject: [PATCH] Fix broken revlist --author when --fixed-string
152 ## Create another topic branch depending on two others non-trivially
153 $ tg create t/whatever t/revlist/author-fixed t/gitweb/nifty-links
154 tg: Creating t/whatever base from t/revlist/author-fixed...
155 tg: Merging t/whatever base with t/gitweb/nifty-links...
156 Merge failed!
157 tg: Please commit merge resolution and call: tg update --continue
158 tg: It is also safe to abort this operation using `git reset --hard`
159 tg: but please remember you are on the base branch now;
160 tg: you will want to switch to a different branch.
161 $ ..resolve..
162 $ git commit
163 $ tg update --continue
164 $ ..hack..
165 $ git commit
167 ## Update a single topic branch and propagate the changes to
168 ## a different one
169 $ git checkout t/gitweb/nifty-links
170 $ ..hack..
171 $ git commit
172 $ git checkout t/whatever
173 $ tg info
174 Topic Branch: t/whatever (1 commit)
175 Subject: [PATCH] Whatever patch
176 Base: 3f47ebc1
177 Depends: t/revlist/author-fixed t/gitweb/nifty-links
178 Needs update from:
179 t/gitweb/nifty-links (1 commit)
180 $ tg update
181 tg: Updating base with t/gitweb/nifty-links changes...
182 Merge failed!
183 tg: Please commit merge resolution and call `tg update --continue`
184 tg: (use `tg status` to see more options)
185 $ ..resolve..
186 $ git commit
187 $ tg update --continue
188 tg: Updating t/whatever against new base...
189 Merge failed!
190 tg: Please commit merge resolution and call `tg update --continue`
191 tg: (use `tg status` to see more options)
192 $ ..resolve..
193 $ git commit
194 $ tg update --continue
196 ## Update a single topic branch and propagate the changes
197 ## further through the dependency chain
198 $ git checkout t/gitweb/pathinfo-action
199 $ ..hack..
200 $ git commit
201 $ git checkout t/whatever
202 $ tg info
203 Topic Branch: t/whatever (1/2 commits)
204 Subject: [PATCH] Whatever patch
205 Base: 0ab2c9b3
206 Depends: t/revlist/author-fixed t/gitweb/nifty-links
207 Needs update from:
208 t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
209 $ tg update
210 tg: Recursing to t/gitweb/nifty-links...
211 [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
212 Merge failed!
213 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
214 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
215 $ ..resolve..
216 $ git commit
217 $ tg update --continue
218 [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base...
219 Merge failed!
220 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update --continue`
221 [t/gitweb/nifty-links] tg: (use `tg status` to see more options)
222 $ ..resolve..
223 $ git commit
224 $ tg update --continue
225 tg: Updating base with t/gitweb/nifty-links changes...
226 tg: Updating t/whatever against new base...
228 ## Clone a TopGit-controlled repository
229 $ git clone URL repo
230 $ cd repo
231 $ tg remote --populate origin
232 ...
233 $ git fetch
234 $ tg update
236 ## Add a TopGit remote to a repository and push to it
237 $ git remote add foo URL
238 $ tg remote foo
239 $ tg push -r foo
241 ## Update from a non-default TopGit remote
242 $ git fetch foo
243 $ tg -r foo summary
244 $ tg -r foo update
247 CONVENTIONS
248 -----------
250 When using TopGit there are several common conventions used when working with
251 TopGit branches. None of them are enforced, they are only suggestions.
253 There are three typical uses for a TopGit branch:
255 1. [PATCH]
256 Normal TopGit branches that represent a single patch. These are known
257 as "patch" TopGit branches.
258 2. [BASE]
259 Empty TopGit branches with no dependencies (an empty ``.topdeps`` file)
260 that represent a base upon which other "normal" TopGit branches depend.
261 These are known as "base" TopGit branches (not to be confused with
262 the refs/top-bases/... refs).
263 3. [STAGE]
264 Empty TopGit branches that serve as a staging area to bring together
265 several other TopGit branches into one place so they can be used/tested
266 all together. These are known as "stage" TopGit branches.
268 An "empty" TopGit branch is one that does not have any changes of its own --
269 it may still have dependencies though ("stage" branches do, "base" branches do
270 not). The ``tg summary`` output shows empty branches with a ``0`` in the
271 listing. Normal "patch" branches that have not been annihilated, "base" and
272 "stage" branches fall into this category. (Annihilated branches are normally
273 omitted from the ``tg summary`` output but can be shown if given explicitly as
274 an argument to the ``tg summary`` command. However, the message line will be
275 incorrect since an annihilated branch has no ``.topmsg`` file of its own.)
277 A "patch" branch name typically starts with ``t/`` whereas "base" and "stage"
278 branch names often do not.
280 A "base" branch is created by using the ``--base`` option of ``tg create``
281 (aka ``--no-deps``) which will automatically suggest a "[BASE]" message prefix
282 rather than "[PATCH]". A "stage" branch is created like a normal patch branch
283 except that the only changes that will ever be made to it are typically to
284 add/remove dependencies. Its subject prefix must be manually changed to
285 "[STAGE]" to reflect its purpose.
287 Since both "base" and "stage" branches typically only have a use for the
288 "Subject:" line from their ``.topmsg`` file, they are quite easily created
289 using the ``--topmsg`` option of ``tg create``.
291 Use of "stage" and "base" branches is completely optional. However, without
292 use of a "stage" branch it will be difficult to test multiple independent
293 patches together all at once. A "base" branch is merely a convenience that
294 provides more explicit control over when a common base for a set of patches
295 gets updated as well as providing a branch that shows in ``tg summary`` output
296 and participates in ``tg remote --populate`` setup.
298 Another advantage to using a "stage" branch is that if a new "patch" branch
299 is created remotely and that new branch is added to a pre-existing "stage"
300 branch on the remote then when the local version of the "stage" branch is
301 updated (after fetching remote updates of course), that new dependency will
302 be merged into the local "stage" branch and the local version of the new remote
303 "patch" branch will be automatically set up at "tg update" time.
305 When using the ``tg tag`` command to create tags that record the current state
306 of one or more TopGit branches, the tags are often created with a name that
307 starts with ``t/``.
309 One last thing, you have enabled ``git rerere`` haven't you?
312 NO UNDO
313 -------
315 Beware, there is no "undo" after running a ``tg update``!
317 Well, that's not entirely correct. Since ``tg update`` never discards commits
318 an "undo" operation is technically feasible provided the old values of all the
319 refs that were affected by the ``tg update`` operation can be determined and
320 then they are simply changed back to their previous values.
322 In practice though, it can be extremely tedious and error prone looking through
323 log information to try and determine what the correct previous values were.
324 Although, since TopGit tries to make sure reflogs are enabled for top-bases
325 refs, using Git's ``@{date}`` notation on all the refs dumped out by a
326 ``tg tag --refs foo``, where "foo" is the branch that was updated whose update
327 needs to be undone, may work.
329 Alternatively, ``tg tag --stash`` can be used prior to the update and then
330 ``tg revert`` used after the update to restore the previous state. This
331 assumes, of course, that you remember to run ``tg tag --stash`` first.
333 The ``tg update`` command understands a ``--stash`` option that tells it to
334 automatically run ``tg tag --stash`` before it starts making changes (if
335 everything is up-to-date it won't run the stash command at all).
337 The ``--stash`` option is the default nowadays when running ``tg update``,
338 add the ``--no-stash`` option to turn it off.
340 There is a preference for this. Setting the config value ``topgit.autostash``
341 to ``false`` will implicitly add the ``--no-stash`` option to any ``tg update``
342 command unless an explicit ``--stash`` option is given.
344 If you are likely to ever want to undo a ``tg update``, setting
345 ``topgit.autostash`` to ``false`` is highly discouraged!
347 Note that the tags saved by ``tg tag --stash`` are stored in the
348 ``refs/tgstash`` ref and its reflog. Unfortunately, while Git is happy to
349 maintain the reflog (once it's been enabled which ``tg tag`` guarantees for
350 ``refs/tgstash``), Git is unable to view an annotated/signed tag's reflog!
351 Instead Git dereferences the tag and shows the wrong thing. Use the
352 ``tg tag -g`` command to view the ``refs/tgstash`` reflog instead.
355 EXTRA SETTINGS
356 --------------
358 TopGit supports various config settings:
360 :ALIASES_: ``topgit.alias.*`` for Git-like command aliases
361 :SEQUESTRATION_: ``topgit.sequester`` for sequestration control
362 :`tg migrate-bases`_: ``topgit.top-bases`` for refs bases location
363 :`tg update`_: ``topgit.autostash`` automatic stash control
364 :`tg patch`_: ``topgit.from`` From: fixups by ``tg patch``
365 :`REMOTE HANDLING`_: ``topgit.remote`` TopGit's default remote
368 ALIASES
369 -------
371 These work exactly like Git's aliases except they are stored under
372 ``topgit.alias.*`` instead. See the ``git help config`` output under
373 the ``alias.*`` section for details. Do note that while alias nesting is
374 explicitly permitted, a maximum nesting depth of 10 is enforced to help
375 detect accidental aliasing loops from wedging the machine.
378 SEQUESTRATION
379 -------------
381 No, this is not a section about budget nonsense. ;)
383 TopGit keeps its metadata in ``.topdeps`` and ``.topmsg`` files. In an effort
384 to facilitate cherry-picking and other Git activities on the patch changes
385 themselves while ignoring the TopGit metadata, TopGit attempts to keep all
386 changes to ``.topdeps`` and ``.topmsg`` files limited to commits that do NOT
387 contain changes to any other files.
389 This is a departure from previous TopGit versions that made no such effort.
391 Primarily this affects ``tg create`` and ``tg import`` (which makes use of
392 ``tg create``) as ``tg create`` will commit the initial versions of
393 ``.topdeps`` and ``.topmsg`` for a new TopGit-controlled branch in their own
394 commit instead of mixing them in with changes to other files.
396 The ``pre-commit`` hook will also attempt to separate out any ``.topdeps`` and
397 ``.topmsg`` changes from commits that include changes to other files.
399 It is possible to defeat these checks without much effort (``pre-commit`` hooks
400 can easily be bypassed, ``tg create`` has a ``--no-commit`` option, many Git
401 commands simply do not run the ``pre-commit`` hook, etc.).
403 If you really, really, really, really want to change the default back to the
404 old behavior of previous TopGit versions where no such sequestration took
405 place, then set the ``topgit.sequester`` config variable explicitly to the
406 value ``false``. But this is not recommended.
409 AMENDING AND REBASING AND UPDATE-REF'ING
410 ----------------------------------------
412 In a word, "don't".
414 It is okay to manually update a top-bases/... ref when a) it has no depedencies
415 (i.e. it was created with the ``tg create`` ``--base`` option) and b) the
416 old top-bases/... ref value can be fast-forwarded to the new top-bases/...
417 value OR the new value contains ALL of the changes in the old value through
418 some other mechanism (perhaps they were cherry-picked or otherwise applied to
419 the new top-bases/... ref). The same rules apply to non-TopGit-controlled
420 dependencies. Use the ``tg update --base <branch> <new-ref>`` command to
421 safely make such an update while making it easy to set the merge commit
422 message at the same time.
424 Ignoring this rule and proceeding anyway with a non-fast-forward update to a
425 top-bases/... ref will result in changes present in the new value being merged
426 into the branch (at ``tg update`` time) as expected (possibly with conflicts),
427 but any changes that were contained in the old version of the top-bases/... ref
428 which have been dropped (i.e. are NOT contained in the new version of the
429 top-bases/... ref) will continue to be present in the branch! To get rid of
430 the dropped commits, one or more "revert" commits will have to be manually
431 applied to the tip of the new top-bases/... value (which will then be merged
432 into the branch at next ``tg update`` time).
434 The only time it's safe to amend, rebase, filter or otherwise rewrite commits
435 contained in a TopGit controlled branch or non-TopGit branch is when those
436 commits are NOT reachable via any other ref!
438 Furthermore, while it is safe to rewrite merge commits (provided they meet the
439 same conditions) the merge commits themselves and the branches they are merging
440 in must be preserved during the rewrite and that can be rather tricky to get
441 right so it's not recommended.
443 For example, if, while working on a TopGit-controlled branch ``foo``, a bad
444 typo is noticed, it's okay to ammend/rebase to fix that provided neither
445 ``tg update`` nor ``tg create`` has already been used to cause some other ref
446 to be able to reach the commit with the typo.
448 If an amend or rerwite is done anyway even though the commit with the typo is
449 reachable from some other ref, the typo won't really be removed. What will
450 happen instead is that the new version without the typo will ultimately be
451 merged into the other ref(s) (at ``tg update`` time) likely causing a conflict
452 that will have to be manually resolved and the commit with the typo will
453 continue to be reachable from those other refs!
455 Instead just make a new commit to fix the typo. The end result will end up
456 being the same but without the merge conflicts.
458 See also the discussion in the `NO UNDO`_ section.
461 SPEED AND CACHING
462 -----------------
464 TopGit needs to check many things to determine whether a TopGit branch is
465 up-to-date or not. This can involve a LOT of git commands for a complex
466 dependency tree. In order to speed things up, TopGit keeps a cache of results
467 in a ``tg-cache`` subdirectory in the ``.git`` directory.
469 Results are tagged with the original hash values used to get that result so
470 that items which have not been changed return their results quickly and items
471 which have been changed compute their new result and cache it for future use.
473 The ``.git/tg-cache`` directory may be removed at any time and the cache will
474 simply be recreated in an on-demand fashion as needed, at some speed penalty,
475 until it's fully rebuilt.
477 To force the cache to be fully pre-loaded, run the ``tg summary`` command
478 without any arguments. Otherwise, normal day-to-day TopGit operations should
479 keep it more-or-less up-to-date.
481 While each TopGit command is running, it uses a temporary subdirectory also
482 located in the ``.git`` directory. These directories are named
483 ``tg-tmp.XXXXXX`` where the ``XXXXXX`` part will be random letters and digits.
485 These temporary directories should always be removed automatically after each
486 TopGit command finishes running. As long as you are not in a subshell as a
487 result of a TopGit command stopping and waiting for a manual merge resolution,
488 it's safe to remove any of these directories that may have somehow accidentally
489 been left behind as a result of some failure that occurred while running a
490 TopGit command (provided, of course, it's not actually being used by a TopGit
491 command currently running in another terminal window or by another user on the
492 same repository).
495 USAGE
496 -----
497 ``tg [-C <dir>] [-r <remote> | -u] [-c <name>=<val>] <subcommand> [<subcommand option/argument>...]``
499 -C <dir> Change directory to <dir> before doing anything
500 -r <remote> Pretend ``topgit.remote`` is set to <remote>
501 -u Pretend ``topgit.remote`` is not set
502 -c <name=val> Pass config option to git, may be repeated
504 The ``tg`` tool has several subcommands:
506 :`tg annihilate`_: Mark a TopGit-controlled branch as defunct
507 :`tg base`_: Show base commit for one or more TopGit branches
508 :`tg checkout`_: Shortcut for git checkout with name matching
509 :`tg contains`_: Which TopGit-controlled branch contains the commit
510 :`tg create`_: Create a new TopGit-controlled branch
511 :`tg delete`_: Delete a TopGit-controlled branch cleanly
512 :`tg depend`_: Add a new dependency to a TopGit-controlled branch
513 :`tg export`_: Export TopGit branch patches to files or a branch
514 :`tg files`_: Show files changed by a TopGit branch
515 :`tg help`_: Show TopGit help optionally using a browser
516 :`tg import`_: Import commit(s) to separate TopGit branches
517 :`tg info`_: Show status information about a TopGit branch
518 :`tg log`_: Run git log limiting revisions to a TopGit branch
519 :`tg mail`_: Shortcut for git send-email with ``tg patch`` output
520 :`tg migrate-bases`_: Transition top-bases to new location
521 :`tg next`_: Show branches directly depending on a TopGit branch
522 :`tg patch`_: Generate a patch file for a TopGit branch
523 :`tg prev`_: Show non-annihilated TopGit dependencies for a branch
524 :`tg push`_: Run git push on TopGit branch(es) and depedencies
525 :`tg rebase`_: Auto continue git rebase if rerere resolves conflicts
526 :`tg remote`_: Set up remote for fetching/pushing TopGit branches
527 :`tg revert`_: Revert ref(s) to a state stored in a ``tg tag``
528 :`tg status`_: Show current TopGit status (e.g. in-progress update)
529 :`tg summary`_: Show various information about TopGit branches
530 :`tg tag`_: Create tag that records current TopGit branch state
531 :`tg update`_: Update TopGit branch(es) with respect to dependencies
533 tg help
534 ~~~~~~~
535 Our sophisticated integrated help facility. Mostly duplicates
536 what is below::
538 # to list commands:
539 $ tg help
540 # to get help for a particular command:
541 $ tg help <command>
542 # to get help for a particular command in a browser window:
543 $ tg help -w <command>
544 # to get help on TopGit itself
545 $ tg help tg
546 # to get help on TopGit itself in a browser
547 $ tg help -w tg
549 tg status
550 ~~~~~~~~~
551 Our sophisticated status facility. Similar to Git's status command
552 but shows any in-progress update that's awaiting a merge resolution
553 or any other on-going TopGit activity (such as a branch creation).
555 With a single ``--verbose`` (or ``-v``) option include a short status
556 display for any dirty (but not untracked) files. This also causes all
557 non file status lines to be prefixed with "## ".
559 With two (or more) ``--verbose`` (or ``-v``) options, additionally
560 show full symbolic ref names and unabbreviated hash values.
562 With the ``--exit-code`` option the exit code will be non-zero if any
563 TopGit or Git operation is currently in progress or the working
564 tree is unclean.
566 tg create
567 ~~~~~~~~~
568 Create a new TopGit-controlled topic branch of the given name
569 (required argument) and switch to it. If no dependencies are
570 specified (by extra arguments passed after the first one), the
571 current branch is assumed to be the only dependency.
573 By default ``tg create`` opens an editor on the new ``.topmsg`` file
574 and then commits the new ``.topmsg`` and ``.topdeps`` files
575 automatically with a suitable default commit message.
577 The commit message can be changed with the ``-m`` (or ``--message``) or
578 ``-F`` (or ``--file``) option. The automatic commit can be suppressed
579 by using the ``--no-ccmmit`` option. Running the editor on the new
580 ``.topmsg`` file can be suppressed by using ``-n`` (or ``--no-edit``)
581 (which also suppresses the automatic commit) or by providing an
582 explicit value for the new ``.topmsg`` file using the ``--topmsg`` or
583 ``--topmsg-file`` option. In any case the ``.topmsg`` content will be
584 automatically reformated to have a ``Subject:`` header line if needed.
586 If more than one dependency is listed, the automatic commit will not
587 take place until AFTER all the listed dependencies have been merged
588 into a base commit which will require some manual merge resolutions if
589 conflicts occur during the merge operations.
591 Previous versions of TopGit behaved as though the ``--no-edit`` option
592 was always given on the command line.
594 The default behavior has been changed to promote a separation between
595 commits that modify ``.topmsg`` and/or ``.topdeps`` and commits that
596 modify other files. This facilitates cleaner cherry picking and other
597 patch maintenance activities.
599 You should edit the patch description (contained in the ``.topmsg``
600 file) as appropriate. It will already contain some prefilled bits.
601 You can set the ``topgit.to``, ``topgit.cc`` and ``topgit.bcc``
602 git configuration variables (see ``man git-config``) in order to
603 have ``tg create`` add these headers with the given default values
604 to ``.topmsg`` before invoking the editor.
606 The main task of ``tg create`` is to set up the topic branch base
607 from the dependencies. This may fail due to merge conflicts if more
608 than one dependency is given. In that case, after you commit the
609 conflict resolution, you should call ``tg update --continue`` to
610 finish merging the dependencies into the new topic branch base.
612 With the ``--base`` (aka ``--no-deps``) option at most one dependency
613 may be listed which may be any valid committish (instead of just
614 refs/heads/...) and the newly created TopGit-controlled branch will
615 have an empty ``.topdeps`` file. This may be desirable in order to
616 create a TopGit-controlled branch that has no changes of its own and
617 serves merely to mark the common dependency that all other
618 TopGit-controlled branches in some set of TopGit-controlled branches
619 depend on. A plain, non-TopGit-controlled branch can be used for the
620 same purpose, but the advantage of a TopGit-controlled branch with no
621 dependencies is that it will be pushed with ``tg push``, it will show
622 up in the ``tg summary`` and ``tg info`` output with the subject from
623 its ``.topmsg`` file thereby documenting what it's for and finally it
624 can be set up with ``tg create -r`` and/or ``tg remote --populate`` to
625 facilitate sharing.
627 For example, ``tg create --base release v2.1`` will create a TopGit-
628 controlled ``release`` branch based off the ``v2.1`` tag that can then
629 be used as a base for creation of other TopGit-controlled branches.
630 Then when the time comes to move the base for an entire set of changes
631 up to ``v2.2`` the command ``tg update --base release v2.2`` can be
632 used followed by ``tg update --all``.
634 Using ``--base`` it's also possible to use ``tg create`` on an
635 unborn branch (omit the dependency name or specify ``HEAD``). The
636 unborn branch itself can be made into the new TopGit branch (rather
637 than being born empty and then having the new TopGit branch based off
638 that) by specifying ``HEAD`` as the new branch's name (which is
639 probably what you normally want to do in this case anyway so you can
640 just run ``tg create --base HEAD`` to accomplish that).
642 In an alternative use case, if ``-r <branch>`` is given instead of a
643 dependency list, the topic branch is created based on the given
644 remote branch. With just ``-r`` the remote branch name is assumed
645 to be the same as the local topic branch being created. Since no
646 new commits are created in this mode (only two refs will be updated)
647 the editor will never be run for this use case. Note that no other
648 options may be combined with ``-r``.
650 The ``--quiet`` (or ``-q``) option suppresses most informational
651 messages.
653 tg delete
654 ~~~~~~~~~
655 Remove a TopGit-controlled topic branch of the given name
656 (required argument). Normally, this command will remove only an
657 empty branch (base == head) without dependendents; use ``-f`` to
658 remove a non-empty branch or a branch that is depended upon by
659 another branch.
661 The ``-f`` option is also useful to force removal of a branch's
662 base, if you used ``git branch -D B`` to remove branch B, and then
663 certain TopGit commands complain, because the base of branch B
664 is still there.
666 Normally ``tg delete`` will refuse to delete the current branch.
667 However, giving ``-f`` twice (or more) will force it to do so but it
668 will first detach your HEAD.
670 IMPORTANT: Currently, this command will *NOT* remove the branch
671 from the dependency list in other branches. You need to take
672 care of this *manually*. This is even more complicated in
673 combination with ``-f`` -- in that case, you need to manually
674 unmerge the removed branch's changes from the branches depending
675 on it.
677 See also ``tg annihilate``.
679 | TODO: ``-a`` to delete all empty branches, depfix, revert
681 tg annihilate
682 ~~~~~~~~~~~~~
683 Make a commit on the current TopGit-controlled topic branch
684 that makes it equal to its base, including the presence or
685 absence of .topmsg and .topdeps. Annihilated branches are not
686 displayed by ``tg summary``, so they effectively get out of your
687 way. However, the branch still exists, and ``tg push`` will
688 push it (except if given the ``-a`` option). This way, you can
689 communicate that the branch is no longer wanted.
691 When annihilating a branch that has dependents (i.e. branches
692 that depend on it), those dependents have the dependencies of
693 the branch being annihilated added to them if they do not already
694 have them as dependencies. Essentially the DAG is repaired to
695 skip over the annihilated branch.
697 Normally, this command will remove only an empty branch
698 (base == head, except for changes to the .top* files); use
699 ``-f`` to annihilate a non-empty branch.
701 After completing the annihilation itself, normally ``tg update``
702 is run on any modified dependents. Use the ``--no-update`` option
703 to suppress running ``tg update``.
705 tg depend
706 ~~~~~~~~~
707 Change the dependencies of a TopGit-controlled topic branch.
708 This should have several subcommands, but only ``add`` is
709 supported right now.
711 The ``add`` subcommand takes an argument naming a topic branch to
712 be added, adds it to ``.topdeps``, performs a commit and then
713 updates your topic branch accordingly. If you want to do other
714 things related to the dependency addition, like adjusting
715 ``.topmsg``, use the option ``--no-commit``. Adding the
716 ``--no-update`` (or ``--no-commit``) option will suppress the
717 ``tg update`` normally performed after committing the change.
719 It is safe to run ``tg depend add`` in a dirty worktree, but the
720 normally performed ``tg update`` will be suppressed in that case
721 (even if neither ``--no-update`` nor ``--no-commit`` is given).
723 You have enabled ``git rerere`` haven't you?
725 | TODO: Subcommand for removing dependencies, obviously
727 tg files
728 ~~~~~~~~
729 List files changed by the current or specified topic branch.
731 Options:
732 -i list files based on index instead of branch
733 -w list files based on working tree instead of branch
735 tg info
736 ~~~~~~~
737 Show summary information about the current or specified topic
738 branch.
740 Numbers in parenthesis after a branch name such as "(11/3 commits)"
741 indicate how many commits on the branch (11) and how many of those
742 are non-merge commits (3).
744 With ``--verbose`` (or ``-v``) include a list of dependents (i.e. other
745 branches that depend on this one). Another ``--verbose`` annotates
746 them with "[needs merge]" if the current tip of branch for which info
747 is being shown has not yet been merged into the base of the dependent.
749 Alternatively, if ``--heads`` is used then which of the independent
750 TopGit branch heads (as output by ``tg summary --topgit-heads``)
751 logically contains the specified commit (which may be any committish --
752 defaults to ``HEAD`` if not given). Zero or more results will be
753 output. Note that "logically" means with regard to the TopGit
754 dependency relationships as established by the ``.topdeps`` file(s).
755 It's the answer that would be given when all the TopGit branches are
756 up-to-date (even though they need not be to use this option) and the
757 ``git branch --contains`` command is run and the output then filtered
758 to only those branches that appear in ``tg summary --topgit-heads``.
759 This computation may require several seconds on complex repositories.
761 If ``--leaves`` is used then the unique list of leaves of the current
762 or specified topic branch is shown as one fully-qualified ref per line.
763 Duplicates are suppressed and a tag name will be used when appropriate.
764 A "leaf" is any dependency that is either not a TopGit branch or is
765 the base of a non-annihilated TopGit branch with no non-annihilated
766 dependencies.
768 A linearized patch series can only be automatically created for a
769 TopGit topic branch (including its recursive dependencies) when exactly
770 one line is output by ``tg info --leaves <topic-branch>``.
772 With ``--series`` the list of TopGit branches in the order they would
773 be linearized into a patch series is shown along with the description
774 of each branch. If branch name passed to ``tg info`` is not the last
775 branch in the series a marker column will be provided to quickly
776 locate it in the list.
778 Some patches shown in the list may not actually end up introducing any
779 changes if exported and be therefore end up being omitted. The ``0``
780 indicator in ``tg summary`` output can help to identify some of these.
782 The patches shown in the series in the order they are shown form the
783 basis for the ``tg next`` and ``tg prev`` operations with the first
784 patch shown being considered the first and so on up to the last.
786 tg patch
787 ~~~~~~~~
788 Generate a patch from the current or specified topic branch.
789 This means that the diff between the topic branch base and head
790 (latest commit) is shown, appended to the description found in
791 the ``.topmsg`` file.
793 The patch is simply dumped to stdout. In the future, ``tg patch``
794 will be able to automatically send the patches by mail or save
795 them to files. (TODO)
797 Options:
798 -i base patch generation on index instead of branch
799 -w base patch generation on working tree instead of branch
800 --binary pass --binary to ``git diff-tree`` to enable generation
801 of binary patches
802 --quiet be quiet (aka ``-q``) about missing and unfixed From:
803 --from make sure patch has a From: line, if not add one using
804 --from=<a> <a> or Signed-off-by value or ident value; ``git am``
805 really gets unhappy with patches missing From: lines;
806 will NOT replace an existing non-empty From: header
807 --no-from leave all From: lines alone, missing or not (default)
808 --diff-opt options after the branch name (and an optional ``--``)
809 are passed directly to ``git diff-tree``
811 In order to pass a sole explicit ``-w`` through to ``git diff-tree`` it
812 must be separated from the ``tg`` options by an explicit ``--``.
813 Or it can be spelled as ``--ignore-all-space`` to distinguuish it from
814 ``tg``'s ``-w`` option.
816 If the config variable ``topgit.from`` is set to a boolean it can be
817 used to enable or disable the ``--from`` option by default. If it's
818 set to the speical value ``quiet`` the ``--quiet`` option is enabled
819 and From: lines are left alone by default. Any other non-empty value
820 is taken as a default ``--from=<value>`` option. The ``--no-from``
821 option will temporarily disable use of the config value.
823 If additional non-``tg`` options are passed through to
824 ``git diff-tree`` (other than ``--binary`` which is fully supported)
825 the resulting ``tg patch`` output may not be appliable.
827 tg mail
828 ~~~~~~~
829 Send a patch from the current or specified topic branch as
830 email(s).
832 Takes the patch given on the command line and emails it out.
833 Destination addresses such as To, Cc and Bcc are taken from the
834 patch header.
836 Since it actually boils down to ``git send-email``, please refer
837 to the documentation for that for details on how to setup email
838 for git. You can pass arbitrary options to this command through
839 the ``-s`` parameter, but you must double-quote everything. The
840 ``-r`` parameter with a msgid can be used to generate in-reply-to
841 and reference headers to an earlier mail.
843 WARNING: be careful when using this command. It easily sends
844 out several mails. You might want to run::
846 git config sendemail.confirm always
848 to let ``git send-email`` ask for confirmation before sending any
849 mail.
851 Options:
852 -i base patch generation on index instead of branch
853 -w base patch generation on working tree instead of branch
855 | TODO: ``tg mail patchfile`` to mail an already exported patch
856 | TODO: mailing patch series
857 | TODO: specifying additional options and addresses on command line
859 tg remote
860 ~~~~~~~~~
861 Register the given remote as TopGit-controlled. This will create
862 the namespace for the remote branch bases and teach ``git fetch``
863 to operate on them. However, from TopGit 0.8 onwards you need to
864 use ``tg push``, or ``git push --mirror``, for pushing
865 TopGit-controlled branches.
867 ``tg remote`` takes an optional remote name argument, and an
868 optional ``--populate`` switch. Use ``--populate`` for your
869 origin-style remotes: it will seed the local topic branch system
870 based on the remote topic branches. ``--populate`` will also make
871 ``tg remote`` automatically fetch the remote, and ``tg update`` look
872 at branches of this remote for updates by default.
874 Using ``--populate`` with a remote name causes the ``topgit.remote``
875 git configuration variable to be set to the given remote name.
877 tg summary
878 ~~~~~~~~~~
879 Show overview of all TopGit-tracked topic branches and their
880 up-to-date status. With a branch name limit output to that branch.
881 Using ``--deps-only`` or ``--rdeps`` changes the default from all
882 related branches to just the current ``HEAD`` branch but using
883 ``--all`` as the branch name will show results for all branches
884 instead of ``HEAD``.
886 ``>``
887 marks the current topic branch
889 ``0``
890 indicates that it introduces no changes of its own
892 ``l``/``r``
893 indicates respectively whether it is local-only
894 or has a remote mate
896 ``L``/``R``
897 indicates respectively if it is ahead or out-of-date
898 with respect to its remote mate
900 ``D``
901 indicates that it is out-of-date with respect to its
902 dependencies
904 ``!``
905 indicates that it has missing dependencies [even if
906 they are recursive ones]
908 ``B``
909 indicates that it is out-of-date with respect to
910 its base
912 ``*``
913 indicates it is ahead of (and needs to be merged into)
914 at least one of its dependents -- only computed when
915 showing all branches or using the (possibly implied)
916 ``--with-deps`` option.
918 This can take a longish time to accurately determine all the
919 relevant information about each branch; you can pass ``-t`` (or ``-l``
920 or ``--list``) to get just a terse list of topic branch names quickly.
921 Also adding ``--verbose`` (or ``-v``) includes the subjects too.
923 If no options or arguments are passed, the default is not actually to
924 show ``--all`` branches (that was the default once upon a time).
925 Instead, the default is essentially ``--with-deps $(tg info --heads)``
926 with a fallback to ``--all`` if ``tg info`` doesn't give up any heads.
927 This usually provides a more intuitive result. Explicitly using
928 ``--all`` will always show all branches (related or not to ``HEAD``).
930 Passing ``--heads`` shows independent topic branch names and when
931 combined with ``--rdeps`` behaves as though ``--rdeps`` were run with
932 the output of ``--heads``.
934 The ``--heads-independent`` option works just like ``--heads`` except
935 that it computes the heads using ``git merge-base --independent``
936 rather than examining the TopGit ``.topdeps`` relationships. If the
937 TopGit branches are all up-to-date (as shown in ``tg summary``) then
938 both ``--heads`` and ``--heads-independent`` should compute the same
939 list of heads (unless some overlapping TopGit branches have been
940 manually created). If not all the TopGit branches are up-to-date then
941 the ``--heads-independent`` results may have extra items in it, but
942 occasionally that's what's needed; usually it's the wrong answer.
943 (Note that ``--topgit-heads`` is accepted as an alias for ``--heads``
944 as well.)
946 Using ``--heads-only`` behaves as though the output of ``--heads`` was
947 passed as the list of branches along with ``--without-deps``.
949 Alternatively, you can pass ``--graphviz`` to get a dot-suitable output
950 for drawing a dependency graph between the topic branches.
952 You can also use the ``--sort`` option to sort the branches using
953 a topological sort. This is especially useful if each
954 TopGit-tracked topic branch depends on a single parent branch,
955 since it will then print the branches in the dependency order.
956 In more complex scenarios, a text graph view would be much more
957 useful, but that has not yet been implemented.
959 The ``--deps`` option outputs dependency information between
960 branches in a machine-readable format. Feed this to ``tsort`` to
961 get the output from --sort.
963 The ``--deps-only`` option outputs a sorted list of the unique branch
964 names given on the command line plus all of their recursive
965 dependencies (subject to ``--exclude`` of course). When
966 ``--deps-only`` is given the default is to just display information for
967 ``HEAD``, but that can be changed by using ``--all`` as the branch
968 name. Each branch name will appear only once in the output no matter
969 how many times it's visited while tracing the dependency graph or how
970 many branch names are given on the command line to process.
972 The ``--rdeps`` option outputs dependency information in an indented
973 text format that clearly shows all the dependencies and their
974 relationships to one another. When ``--rdeps`` is given the default is
975 to just display information for ``HEAD``, but that can be changed by
976 using ``--all`` as the branch name or by adding the ``--heads`` option.
977 Note that ``tg summary --rdeps --heads`` can be particularly helpful in
978 seeing all the TopGit-controlled branches in the repository and their
979 relationships to one another.
981 Note that ``--rdeps`` has two flavors. The first (and default) is
982 ``--rdeps-once`` which only shows the dependencies of a branch when
983 it's first visited. For example, if D depends on several other
984 branches perhaps recursively and both branch A and B depend on D, then
985 whichever of A or B is shown first will show the entire dependency
986 chain for D underneath it and the other one will just show a line for
987 D itself. This can make the output a bit more compact without actually
988 losing any information which is why it's the default. However, using
989 the ``--rdeps-full`` variant will repeat the full dependency chain
990 every time it's encountered.
992 Adding ``--with-deps`` replaces the given list of branches (which will
993 default to ``HEAD`` if none are given) with the result of running
994 ``tg summary --deps-only --tgish`` on the list of branches. This can
995 be helpful in limiting ``tg summary`` output to only the list of given
996 branches and their dependencies when many TopGit-controlled branches
997 are present in the repository. When it would be allowed,
998 ``--with-deps`` is now the default. Use ``--without-deps`` to switch
999 back to the old behavior.
1001 With ``--exclude branch``, branch can be excluded from the output
1002 meaning it will be skipped and its name will be omitted from any
1003 dependency output. The ``--exclude`` option may be repeated to omit
1004 more than one branch from the output. Limiting the output to a single
1005 branch that has been excluded will result in no output at all.
1007 The ``--tgish-only`` option behaves as though any non-TopGit-controlled
1008 dependencies encountered during processing had been listed after an
1009 ``--exclude`` option.
1011 Note that the branch name can be specified as ``HEAD`` or ``@`` as a
1012 shortcut for the TopGit-controlled branch that ``HEAD`` is a
1013 symbolic ref to. The ``tg summary @`` command can be quite useful.
1015 Options:
1016 -i Use TopGit metadata from the index instead of the branch
1017 -w Use TopGit metadata from the working tree instead of the branch
1019 tg contains
1020 ~~~~~~~~~~~
1021 Search all TopGit-controlled branches (and optionally their remotes)
1022 to find which TopGit-controlled branch contains the specified commit.
1024 This is more than just basic branch containment as provided for by the
1025 ``git branch --contains`` command. While the shown branch name(s)
1026 will, indeed, be one (or more) of those output by the
1027 ``git branch --contains`` command, the result(s) will exclude any
1028 TopGit-controlled branches from the result(s) that have one (or more)
1029 of their TopGit dependencies (either direct or indirect) appearing in
1030 the ``git branch --contains`` output.
1032 Normally the result will be only the one, single TopGit-controlled
1033 branch for which the specified committish appears in the ``tg log``
1034 output for that branch (unless the committish lies outside the
1035 TopGit-controlled portion of the DAG and ``--no-strict`` was used).
1037 Unless ``--annihilated-okay`` (or ``--ann`` or ``--annihilated``) is
1038 used then annihilated branches will be immediately removed from the
1039 ``git branch --contains`` output before doing anything else. This
1040 means a committish that was originally located in a now-annihilated
1041 branch will show up in whatever branch picked up the annihilated
1042 branch's changes (if there is one). This is usually the correct
1043 answer, but occasionally it's not; hence this option. If this option
1044 is used together with ``--verbose`` then annihilated branches will
1045 be shown as "[:annihilated:]".
1047 In other words, if a ``tg patch`` is generated for the found branch
1048 (assuming one was found and a subsequent commit in the same branch
1049 didn't then revert or otherwise back out the change), then that patch
1050 will include the changes introduced by the specified committish
1051 (unless, of course, that committish is outside the TopGit-controlled
1052 portion of the DAG and ``--no-strict`` was given).
1054 This can be very helpful when, for example, a bug is discovered and
1055 then after using ``git bisect`` (or some other tool) to find the
1056 offending commit it's time to commit the fix. But because the
1057 TopGit merging history can be quite complicated and maybe the one
1058 doing the fix wasn't the bug's author (or the author's memory is just
1059 going), it can sometimes be rather tedious to figure out which
1060 TopGit branch the fix belongs in. The ``tg contains`` command can
1061 quickly tell you the answer to that question.
1063 With the ``--remotes`` (or ``-r``) option a TopGit-controlled remote
1064 branch name may be reported as the result but only if there is no
1065 non-remote branch containing the committish (this can only happen
1066 if at least one of the TopGit-controlled local branches are not yet
1067 up-to-date with their remotes).
1069 With the ``--verbose`` option show which TopGit DAG head(s) (one or
1070 more of the TopGit-controlled branch names output by
1071 ``tg summary --heads``) have the result as a dependency (either direct
1072 or indirect). Using this option will noticeably increase running time.
1074 With the default ``--strict`` option, results for which the base of the
1075 TopGit-controlled branch contains the committish will be suppressed.
1076 For example, if the committish was deep-down in the master branch
1077 history somewhere far outside of the TopGit-controlled portion of
1078 the DAG, with ``--no-strict``, whatever TopGit-controlled branch(es)
1079 first picked up history containing that committish will be shown.
1080 While this is a useful result it's usually not the desired result
1081 which is why it's not the default.
1083 To summarize, even with ``--remotes``, remote results are only shown
1084 if there are no non-remote results. Without ``--no-strict`` (because
1085 ``--strict`` is the default) results outside the TopGit-controlled
1086 portion of the DAG are never shown and even with ``--no-strict`` they
1087 will only be shown if there are no ``--strict`` results. Finally,
1088 the TopGit head info shown with ``--verbose`` only ever appears for
1089 local (i.e. not a remote branch) results. Annihilated branches are
1090 never considered possible matches without ``--annihilated-okay``.
1092 tg checkout
1093 ~~~~~~~~~~~
1094 Switch to a topic branch. You can use ``git checkout <branch>``
1095 to get the same effect, but this command helps you navigate
1096 the dependency graph, or allows you to match the topic branch
1097 name using a regular expression, so it can be more convenient.
1099 There following subcommands are available:
1101 ``tg checkout push``
1102 Check out a branch that directly
1103 depends on your current branch.
1105 ``tg checkout pop``
1106 Check out a branch that this branch
1107 directly depends on.
1109 ``tg checkout [goto] [--] <pattern>``
1110 Check out a topic branch that
1111 matches ``<pattern>``. ``<pattern>``
1112 is used as a sed pattern to filter
1113 all the topic branches. Both ``goto`` and
1114 ``--`` may be omitted provided ``<pattern>``
1115 is not ``push``, ``pop``, ``-a``, ``--all``,
1116 ``goto``, ``..``, ``--``, ``next``, ``child``,
1117 ``prev``, ``parent``, ``-h`` or ``--help``.
1119 ``tg checkout next``
1120 An alias for ``push``.
1122 ``tg checkout child``
1123 An alias for ``push``.
1125 ``tg checkout``
1126 An alias for ``push``.
1128 ``tg checkout prev``
1129 An alias for ``pop``.
1131 ``tg checkout parent``
1132 An alias for ``pop``.
1134 ``tg checkout ..``
1135 An alias for ``pop``.
1137 If any of the above commands can find more than one possible
1138 branch to switch to, you will be presented with the matches
1139 and asked to select one of them.
1141 If the ``--ignore-other-worktrees`` (or ``--iow``) option is given and
1142 the current Git version is at least 2.5.0 then the full
1143 ``--ignore-other-worktrees`` option will be passed along to the
1144 ``git checkout`` command when it's run (otherwise the option will be
1145 silently ignored and not passed to Git as it would cause an error).
1147 The ``--force`` (or ``-f``) option, when given, gets passed through to
1148 the ``git checkout`` command.
1150 The ``<pattern>`` of ``tg checkout goto`` is optional. If you don't
1151 supply it, all the available topic branches are listed and you
1152 can select one of them.
1154 Normally, the ``push`` and ``pop`` commands moves one step in
1155 the dependency graph of the topic branches. The ``-a`` option
1156 causes them (and their aliases) to move as far as possible.
1157 That is, ``tg checkout push -a`` moves to a topic branch that
1158 depends (directly or indirectly) on the current branch and
1159 that no other branch depends on. ``tg checkout pop -a``
1160 moves to a regular branch that the current topic branch
1161 depends on (directly or indirectly). If there is more than
1162 one possibility, you will be prompted for your selection.
1164 tg export
1165 ~~~~~~~~~
1166 Export a tidied-up history of the current topic branch and its
1167 dependencies, suitable for feeding upstream. Each topic branch
1168 corresponds to a single commit or patch in the cleaned up
1169 history (corresponding basically exactly to ``tg patch`` output
1170 for the topic branch).
1172 The command has three possible outputs now -- either a Git branch
1173 with the collapsed history, a Git branch with a linearized
1174 history, or a quilt series in new directory.
1176 In the case where you are producing collapsed history in a new
1177 branch, you can use this collapsed structure either for
1178 providing a pull source for upstream, or for further
1179 linearization e.g. for creation of a quilt series using git log::
1181 git log --pretty=email -p --topo-order origin..exported
1183 To better understand the function of ``tg export``, consider this
1184 dependency structure::
1186 origin/master - t/foo/blue - t/foo/red - master
1187 `- t/bar/good <,----------'
1188 `- t/baz ------------'
1190 (where each of the branches may have a hefty history). Then::
1192 master$ tg export for-linus
1194 will create this commit structure on the branch ``for-linus``::
1196 origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
1197 `- t/bar/good <,-------------------'/
1198 `- t/baz ---------------------'
1200 In this mode, ``tg export`` works on the current topic branch, and
1201 can be called either without an option (in that case,
1202 ``--collapse`` is assumed), or with the ``--collapse`` option, and
1203 with one mandatory argument: the name of the branch where the
1204 exported result will be stored.
1206 When using the linearize mode::
1208 master$ tg export --linearize for-linus
1210 you get a linear history respecting the dependencies of your
1211 patches in a new branch ``for-linus``. The result should be more
1212 or less the same as using quilt mode and then reimporting it
1213 into a Git branch. (More or less because the topological order
1214 can usually be extended in more than one way into a total order,
1215 and the two methods may choose different ones.) The result
1216 might be more appropriate for merging upstream, as it contains
1217 fewer merges.
1219 Note that you might get conflicts during linearization because
1220 the patches are reordered to get a linear history. If linearization
1221 would produce conflicts then using ``--quilt`` will also likely result
1222 in conflicts when the exported quilt series is applied. Since the
1223 ``--quilt`` mode simply runs a series of ``tg patch`` commands to
1224 generate the patches in the exported quilt series and those patches
1225 will end up being applied linearly, the same conflicts that would be
1226 produced by the ``--linearize`` option will then occur at that time.
1228 To avoid conflicts produced by ``--linearize`` (or by applying the
1229 ``--quilt`` output), use the default ``--collapse`` mode and then use
1230 ``tg rebase`` (or ``git rebase -m`` directly) on the collapsed branch
1231 (with a suitable <upstream>) followed by ``git format-patch`` on the
1232 rebased result to produce a conflict-free patch set. A suitable
1233 upstream may be determined with the ``tg info --leaves`` command (if
1234 it outputs more than one line, linearization will be problematic).
1236 You have enabled ``git rerere`` haven't you?
1238 When using the quilt mode::
1240 master$ tg export --quilt for-linus
1242 would create the following directory ``for-linus``::
1244 for-linus/t/foo/blue.diff
1245 for-linus/t/foo/red.diff
1246 for-linus/t/bar/good.diff
1247 for-linus/t/baz.diff
1248 for-linus/series:
1249 t/foo/blue.diff -p1
1250 t/bar/good.diff -p1
1251 t/foo/red.diff -p1
1252 t/baz.diff -p1
1254 With ``--quilt``, you can also pass the ``-b`` parameter followed
1255 by a comma-separated explicit list of branches to export, or
1256 the ``--all`` parameter (which can be shortened to ``-a``) to
1257 export them all. The ``--binary`` option enables producing Git
1258 binary patches. These options are currently only supported
1259 with ``--quilt``.
1261 In ``--quilt`` mode the patches are named like the originating
1262 topgit branch. So usually they end up in subdirectories of the
1263 output directory. With the ``--flatten`` option the names are
1264 mangled so that they end up directly in the output dir (slashes
1265 are replaced with underscores). With the ``--strip[=N]`` option
1266 the first ``N`` subdirectories (all if no ``N`` is given) get
1267 stripped off. Names are always ``--strip``'d before being
1268 ``--flatten``'d. With the option ``--numbered`` (which implies
1269 ``--flatten``) the patch names get a number as prefix to allow
1270 getting the order without consulting the series file, which
1271 eases sending out the patches.
1273 | TODO: Make stripping of non-essential headers configurable
1274 | TODO: Make stripping of [PATCH] and other prefixes configurable
1275 | TODO: ``--mbox`` option to export instead as an mbox file
1276 | TODO: support ``--all`` option in other modes of operation
1277 | TODO: For quilt exporting, export the linearized history created in
1278 a temporary branch--this would allow producing conflict-less
1279 series
1281 tg import
1282 ~~~~~~~~~
1283 Import commits within the given revision range into TopGit,
1284 creating one topic branch per commit. The dependencies are set
1285 up to form a linear sequence starting on your current branch --
1286 or a branch specified by the ``-d`` parameter, if present.
1288 The branch names are auto-guessed from the commit messages and
1289 prefixed by ``t/`` by default; use ``-p <prefix>`` to specify an
1290 alternative prefix (even an empty one).
1292 Alternatively, you can use the ``-s NAME`` parameter to specify
1293 the name of the target branch; the command will then take one
1294 more argument describing a *single* commit to import.
1296 tg update
1297 ~~~~~~~~~
1298 Update the current, specified or all topic branches with respect
1299 to changes in the branches they depend on and remote branches.
1300 This is performed in two phases -- first, changes within the
1301 dependencies are merged to the base, then the base is merged
1302 into the topic branch. The output will guide you on what to do
1303 next in case of conflicts.
1305 You have enabled ``git rerere`` haven't you?
1307 If you also enable the ``rerere.autoUpdate`` mode then ``tg update``
1308 will be able to automatically continue an update when ``git rerere``
1309 resolves all the conflicts and then stages the results in the index.
1310 This can be a big time saver.
1312 When ``-a`` (or ``--all``) is specifed, updates all topic branches
1313 matched by ``<pattern>``'s (see ``git-for-each-ref(1)`` for details),
1314 or all if no ``<pattern>`` is given. Any topic branches with missing
1315 dependencies will be skipped entirely unless ``--skip-missing`` is
1316 specified.
1318 When ``--skip-missing`` is specifed, an attempt is made to update topic
1319 branches with missing dependencies by skipping only the dependencies
1320 that are missing. Caveat utilitor.
1322 When ``--stash`` is specified (or the ``topgit.autostash`` config
1323 value is set to ``true``), a ref stash will be automatically created
1324 just before beginning updates if any are needed. The ``--no-stash``
1325 option may be used to disable a ``topgit.autostash=true`` setting.
1326 See the ``tg tag`` ``--stash`` option for details.
1328 After the update, if a single topic branch was specified, it is
1329 left as the current one; if ``-a`` was specified, it returns to
1330 the branch which was current at the beginning.
1332 If your dependencies are not up-to-date, ``tg update`` will first
1333 recurse into them and update them.
1335 If a remote branch update brings in dependencies on branches
1336 that are not yet instantiated locally, you can either bring in
1337 all the new branches from the remote using ``tg remote
1338 --populate``, or only pick out the missing ones using ``tg create
1339 -r`` (``tg summary`` will point out branches with incomplete
1340 dependencies by showing an ``!`` next to them). TopGit will attempt to
1341 instantiate just the missing ones automatically for you, if possible,
1342 when ``tg update`` merges in the new dependencies from the remote.
1344 Using the alternative ``--base`` mode, ``tg update`` will update
1345 the base of a specified ``[BASE]`` branch (which is a branch created
1346 by ``tg create`` using the ``--base`` option) to the specified
1347 committish (the second argument) and then immediately merge that into
1348 the branch itself using the specified message for the merge commit.
1349 If no message is specified on the command line, an editor will open.
1350 Unless ``--force`` is used the new value for the base must contain
1351 the old value (i.e. be a fast-forward update). This is for safety.
1353 This mode makes updates to ``[BASE]`` branches quick and easy.
1355 | TODO: ``tg update -a -c`` to autoremove (clean) up-to-date branches
1357 tg push
1358 ~~~~~~~
1359 If ``-a`` or ``--all`` was specified, pushes all non-annihilated
1360 TopGit-controlled topic branches, to a remote repository.
1361 Otherwise, pushes the specified topic branches -- or the
1362 current branch, if you don't specify which. By default, the
1363 remote gets all the dependencies (both TopGit-controlled and
1364 non-TopGit-controlled) and bases pushed to it too. If
1365 ``--tgish-only`` was specified, only TopGit-controlled
1366 dependencies will be pushed, and if ``--no-deps`` was specified,
1367 no dependencies at all will be pushed.
1369 The ``--dry-run`` and ``--force`` options are passed directly to
1370 ``git push`` if given.
1372 The remote may be specified with the ``-r`` option. If no remote
1373 was specified, the configured default TopGit remote will be
1374 used.
1376 tg base
1377 ~~~~~~~
1378 Prints the base commit of each of the named topic branches, or
1379 the current branch if no branches are named. Prints an error
1380 message and exits with exit code 1 if the named branch is not
1381 a TopGit branch.
1383 tg log
1384 ~~~~~~
1385 Prints the git log of the named topgit branch -- or the current
1386 branch, if you don't specify a name.
1388 This is really just a convenient shortcut for:
1390 ``git log --first-parent --no-merges $(tg base <name>)..<name>``
1392 where ``<name>`` is the name of the TopGit topic branch (or omitted
1393 for the current branch).
1395 However, if ``<name>`` is a ``[BASE]`` branch the ``--no-merges``
1396 option is omitted.
1398 If ``--compact`` is used then ``git log-compact`` will be used instead
1399 of ``git log``. The ``--command=<git-alias>`` option can be used to
1400 replace "log" with any non-whitespace-containing command alias name,
1401 ``--compact`` is just a shortcut for ``--command=log-compact``. The
1402 ``git-log-compact`` tool may be found on its project page located at:
1404 https://mackyle.github.io/git-log-compact
1406 Note that the ``--compact`` or ``--command=`` option must be used
1407 before any ``--`` or ``git log`` options to be recognized.
1409 NOTE: if you have merged changes from a different repository, this
1410 command might not list all interesting commits.
1412 tg tag
1413 ~~~~~~
1414 Creates a TopGit annotated/signed tag or lists the reflog of one.
1416 A TopGit annotated tag records the current state of one or more TopGit
1417 branches and their dependencies and may be used to revert to the tagged
1418 state at any point in the future.
1420 When reflogs are enabled (the default in a non-bare repository) and
1421 combined with the ``--force`` option a single tag name may be used as a
1422 sort of TopGit branch state stash. The special branch name ``--all``
1423 may be used to tag the state of all current TopGit branches to
1424 facilitate this function and has the side-effect of suppressing the
1425 out-of-date check allowing out-of-date branches to be included.
1427 As a special feature, ``--stash`` may be used as the tag name in which
1428 case ``--all`` is implied if no branch name is listed (instead of the
1429 normal default of ``HEAD``), ``--force`` and ``--no-edit`` (use
1430 ``--edit`` to change that) are automatically activated and the tag will
1431 be saved to ``refs/tgstash`` instead of ``refs/tags/<tagname>``.
1432 The ``--stash`` tag name may also be used with the ``-g``/``--reflog``
1433 option.
1435 The mostly undocumented option ``--allow-outdated`` will bypass the
1436 out-of-date check and is implied when ``--stash`` or ``--all`` is used.
1438 A TopGit annotated/signed tag is simply a Git annotated/signed tag with
1439 a "TOPGIT REFS" section appended to the end of the tag message (and
1440 preceding the signature for signed tags). PEM-style begin and end
1441 lines surround one line per ref where the format of each line is
1442 full-hash SP ref-name. A line will be included for each branch given
1443 on the command line and each ref they depend on either directly or
1444 indirectly.
1446 If more than one TopGit branch is given on the command line, a new
1447 commit will be created that has an empty tree and all of the given
1448 TopGit branches as parents and that commit will be tagged. If a single
1449 TopGit branch is given, then it will be tagged. If the ``--tree``
1450 option is used then it will be used instead of an empty tree (a new
1451 commit will be created if necessary to guarantee the specified tree is
1452 what's in the commit the newly created tag refers to). The argument to
1453 the ``--tree`` option may be any valid treeish.
1455 If exactly one of the branches to be tagged is prefixed with a tilde
1456 (``~``) it will be made the first parent of a consolidation commit if
1457 it is not already the sole commit needing to be tagged. If ``--tree``
1458 is NOT used, its tree will also be used instead of the empty tree for
1459 any new consolidation commit if one is created. Note that if
1460 ``--tree`` is given explicitly it's tree is always used but that does
1461 not in any way affect the choice of first parent. Beware that the
1462 ``~`` may need to be quoted to prevent the shell from misinterpreting
1463 it into something else.
1465 All the options for creating a tag serve the same purpose as their Git
1466 equivalents except for two. The ``--refs`` option suppresses tag
1467 creation entirely and emits the "TOPGIT REFS" section that would have
1468 been included with the tag. If the ``--no-edit`` option is given and
1469 no message is supplied (via the ``-m`` or ``-F`` option) then the
1470 default message created by TopGit will be used without running the
1471 editor.
1473 With ``-g`` or ``--reflog`` show the reflog for a tag. With the
1474 ``--reflog-message`` option the message from the reflog is shown.
1475 With the ``--commit-message`` option the first line of the tag's
1476 message (if the object is a tag) or the commit message (if the object
1477 is a commit) falling back to the reflog message for tree and blob
1478 objects is shown. The default is ``--reflog-message`` unless the
1479 ``--stash`` (``refs/tgstash``) is being shown in which case the default
1480 is then ``--commit-message``. Just add either option explicitly to
1481 override the default.
1483 When showing reflogs, non-tag entries are annotated with their type
1484 unless ``--no-type`` is given.
1486 TopGit tags are created with a reflog if core.logallrefupdates is
1487 enabled (the default for non-bare repositories). Unfortunately Git
1488 is incapable of showing an annotated/signed tag's reflog
1489 (using git log -g) as it will first resolve the tag before checking to
1490 see if it has a reflog. Git can, however, show reflogs for lightweight
1491 tags (using git log -g) just fine but that's not helpful here. Use
1492 ``tg tag`` with the ``-g`` or ``--reflog`` option to see the reflog for
1493 an actual tag object. This also works on non-TopGit annotated/signed
1494 tags as well provided they have a reflog.
1496 The number of entries shown may be limited with the ``-n`` option. If
1497 the tagname is omitted then ``--stash`` is assumed.
1499 The ``--delete`` option is a convenience option that runs the
1500 ``git update-ref -d`` command on the specified tag removing it and its
1501 reflog (if it has one).
1503 The ``--clear`` option clears all but the most recent (the ``@{0}``)
1504 reflog entries from the reflog for the specified tag. It's equivalent
1505 to dropping all the higher numbered reflog entries.
1507 The ``--drop`` option drops the specified reflog entry and requires the
1508 given tagname to have an ``@{n}`` suffix where ``n`` is the reflog
1509 entry number to be dropped. This is really just a convenience option
1510 that runs the appropriate ``git reflog delete`` command.
1512 Note that when combined with ``tg revert``, a tag created by ``tg tag``
1513 can be used to transfer TopGit branches. Simply create the tag, push
1514 it somewhere and then have the recipient run ``tg revert`` to recreate
1515 the TopGit branches. This may be helpful in situations where it's not
1516 feasible to push all the refs corresponding to the TopGit-controlled
1517 branches and their top-bases.
1519 tg rebase
1520 ~~~~~~~~~
1521 Provides a ``git rebase`` rerere auto continue function. It may be
1522 used as a drop-in replacement front-end for ``git rebase -m`` that
1523 automatically continues the rebase when ``git rerere`` information is
1524 sufficient to resolve all conflicts.
1526 You have enabled ``git rerere`` haven't you?
1528 If the ``-m`` or ``--merge`` option is not present then ``tg rebase``
1529 will complain and not do anything.
1531 When ``git rerere`` is enabled, previously resolved conflicts are
1532 remembered and can be automatically staged (see ``rerere.autoUpdate``).
1534 However, even with auto staging, ``git rebase`` still stops and
1535 requires an explicit ``git rebase --continue`` to keep going.
1537 In the case where ``git rebase -m`` is being used to flatten history
1538 (such as after a ``tg export --collapse`` prior to a
1539 ``git format-patch``), there's a good chance all conflicts have already
1540 been resolved during normal merge maintenance operations so there's no
1541 reason ``git rebase`` could not automatically continue, but there's no
1542 option to make it do so.
1544 The ``tg rebase`` command provides a ``git rebase --auto-continue``
1545 function.
1547 All the same rebase options can be used (they are simply passed through
1548 to Git unchanged). However, the ``rerere.autoUpdate`` option is
1549 automatically temporarily enabled while running ``git rebase`` and
1550 should ``git rebase`` stop asking one to resolve and continue, but all
1551 conflicts have already been resolved and staged using rerere
1552 information, then ``git rebase --continue`` will be automatically run.
1554 tg revert
1555 ~~~~~~~~~
1556 Provides the ability to revert one or more TopGit branches and their
1557 dependencies to a previous state contained within a tag created using
1558 the ``tg tag`` command. In addition to the actual revert mode
1559 operation a list mode operation is also provided to examine a tag's ref
1560 contents.
1562 The default mode (``-l`` or ``--list``) shows the state of one or more
1563 of the refs/branches stored in the tag data. When no refs are given on
1564 the command line, all refs in the tag data are shown. With the special
1565 ref name ``--heads`` then the indepedent heads contained in the tag
1566 data are shown. The ``--deps`` option shows the specified refs and all
1567 of their dependencies in a single list with no duplicates. The
1568 ``--rdeps`` option shows a display similar to ``tg summary --rdeps``
1569 for each ref or all TopGit heads if no ref is given on the command
1570 line. The standard ``--no-short``, ``--short=n`` etc. options may be
1571 used to override the default ``--short`` output. With ``--hash`` (or
1572 ``--hash-only``) show only the hash in ``--list`` mode in which case
1573 the default is ``--no-short``. The ``--hash`` option can be used much
1574 like the ``git rev-parse --verify`` command to extract a specific hash
1575 value out of a TopGit tag.
1577 Note that unlike `tg summary`_, here ``--heads`` actually does mean the
1578 ``git merge-base --independent`` heads of the stored refs from the tag
1579 data. To see only the independent TopGit topic branch heads stored in
1580 the tag data use the ``--topgit-heads`` option instead. The default
1581 for the ``--rdeps`` option is ``--topgit-heads`` but ``--heads`` can
1582 be given explicitly to change that. (Note that ``--heads-independent``
1583 is accepted as an alias for ``--heads`` as well.)
1585 The revert mode has three submodes, dry-run mode (``-n`` or
1586 ``--dry-run``), force mode (``-f`` or ``--force``) and interactive mode
1587 (``-i`` or ``--interactive``). If ``--dry-run`` (or ``-n``) is given
1588 no ref updates will actually be performed but what would have been
1589 updated is shown instead. If ``--interactive`` (or ``-i``) is given
1590 then the editor is invoked on an instruction sheet allowing manual
1591 selection of the refs to be updated before proceeding. Since revert is
1592 potentially a destructive operation, at least one of the submodes must
1593 be specified explicitly. If no refs are listed on the command line
1594 then all refs in the tag data are reverted. Otherwise the listed refs
1595 and all of their dependencies (unless ``--no-deps`` is given) are
1596 reverted. Unless ``--no-stash`` is given a new stash will be created
1597 using ``tg tag --stash`` (except, of course, in dry-run mode) just
1598 before actually performing the updates to facilitate recovery from
1599 accidents.
1601 Both modes accept fully-qualified (i.e. starts with ``refs/``) ref
1602 names as well as unqualified names (which will be assumed to be located
1603 under ``refs/heads/``). In revert mode a tgish ref will always have
1604 both its ``refs/heads/`` and ``refs/top-bases/`` values included no
1605 matter how it's listed unless ``--no-deps`` is given and the ref is
1606 fully qualified (i.e. starts with ``refs/``) or one or the other of its
1607 values was removed from the instruction sheet in interactive mode. In
1608 list mode a tgish ref will always have both its ``refs/heads/`` and
1609 ``refs/top-bases/`` values included only when using the ``--deps`` or
1610 ``--rdeps`` options.
1612 The ``--tgish-only`` option excludes non-tgish refs (i.e. refs that do
1613 not have a ``refs/heads/<name>``, ``refs/top-bases/<name>`` pair).
1615 The ``--exclude`` option (which can be repeated) excludes specific
1616 refs. If the name given to ``--exclude`` is not fully-qualified (i.e.
1617 starts with ``refs/``) then it will exclude both members of a tgish ref
1618 pair.
1620 The ``--quiet`` (or ``-q``) option may be used in revert mode to
1621 suppress non-dry-run ref change status messages.
1623 The special tag name ``--stash`` (as well as with ``@{n}`` suffixes)
1624 can be used to refer to ``refs/tgstash``.
1626 The ``tg revert`` command supports tags of tags that contains TopGit
1627 refs. So, for example, if you do this::
1629 tg tag newtag --all
1630 git tag -f -a -m "tag the tag" newtag newtag
1632 Then ``newtag`` will be a tag of a tag containing a ``TOPGIT REFS``
1633 section. ``tg revert`` knows how to dereference the outermost
1634 tag to get to the next (and the next etc.) tag to find the
1635 ``TOPGIT REFS`` section so after the above sequence, the tag ``newtag``
1636 can still be used successfully with ``tg revert``.
1638 NOTE: If HEAD points to a ref that is updated by a revert operation
1639 then NO WARNING whatsoever will be issued, but the index and working
1640 tree will always be left completely untouched (and the reflog for
1641 the pointed-to ref can always be used to find the previous value).
1643 tg prev
1644 ~~~~~~~
1645 Outputs the direct dependencies for the current or named branch.
1647 Options:
1648 -i show dependencies based on index instead of branch
1649 -w show dependencies based on working tree instead of branch
1651 tg next
1652 ~~~~~~~
1653 Outputs all branches which directly depend on the current or
1654 named branch.
1656 Options:
1657 -i show dependencies based on index instead of branch
1658 -w show dependencies based on working tree instead of branch
1660 tg migrate-bases
1661 ~~~~~~~~~~~~~~~~
1662 Transition top-bases from old location to new location.
1664 Beginning with TopGit release 0.19.4, TopGit has the ability to store
1665 the top-bases refs in either the old ``ref/top-bases/...`` location or
1666 the new ``refs/heads/{top-bases}/...`` location. Starting with TopGit
1667 release 0.20.0, the default is the new location.
1669 By storing the top-bases under heads, Git is less likely to complain
1670 when manipulating them, hosting providers are more likely to provide
1671 access to them and Git prevents them from pointing at anything other
1672 than a commit object. All in all a win for everyone.
1674 TopGit attempts to automatically detect whether the new or old location
1675 is being used for the top-bases and just do the right thing. However,
1676 by explicitly setting the config value ``topgit.top-bases`` to either
1677 ``refs`` for the old location or ``heads`` for the new location the
1678 auto-detection can be bypassed. If no top-bases refs are present in
1679 the repository the default prior to TopGit release 0.20.0 is to use the
1680 old location but starting with TopGit release 0.20.0 the default is to
1681 use the new location.
1683 The ``tg migrate-bases`` command may be used to migrate top-bases refs
1684 from the old location to the new location (or, by using the
1685 undocumented ``--reverse`` option, vice versa).
1687 With few exceptions (``tg create -r`` and ``tg revert``), all top-bases
1688 refs (both local *and* remote refs) are expected to be stored in the
1689 same location (either new or old). A repository's current location for
1690 storing top-bases refs may be shown with the ``tg --top-bases`` command.
1692 TODO: tg rename
1693 ~~~~~~~~~~~~~~~
1695 IMPLEMENTATION
1696 --------------
1698 TopGit stores all the topic branches in the regular ``refs/heads/``
1699 namespace (so we recommend distinguishing them with the ``t/`` prefix).
1700 Apart from that, TopGit also maintains a set of auxiliary refs in
1701 ``refs/top-*``. Currently, only ``refs/top-bases/`` is used, containing the
1702 current *base* of the given topic branch -- this is basically a merge of
1703 all the branches the topic branch depends on; it is updated during ``tg
1704 update`` and then merged to the topic branch, and it is the base of a
1705 patch generated from the topic branch by ``tg patch``.
1707 All the metadata is tracked within the source tree and history of the
1708 topic branch itself, in ``.top*`` files; these files are kept isolated
1709 within the topic branches during TopGit-controlled merges and are of
1710 course omitted during ``tg patch``. The state of these files in base
1711 commits is undefined; look at them only in the topic branches
1712 themselves. Currently, two files are defined:
1714 ``.topmsg``:
1715 Contains the description of the topic branch in a
1716 mail-like format, plus the author information, whatever
1717 Cc headers you choose or the post-three-dashes message.
1718 When mailing out your patch, basically only a few extra
1719 mail headers are inserted and then the patch itself is
1720 appended. Thus, as your patches evolve, you can record
1721 nuances like whether the particular patch should have
1722 To-list / Cc-maintainer or vice-versa and similar
1723 nuances, if your project is into that. ``From`` is
1724 prefilled from your current ``GIT_AUTHOR_IDENT``; other
1725 headers can be prefilled from various optional
1726 ``topgit.*`` git config options.
1728 ``.topdeps``:
1729 Contains the one-per-line list of branches this branch
1730 depends on, pre-seeded by ``tg create``. A (continuously
1731 updated) merge of these branches will be the *base* of
1732 your topic branch.
1734 IMPORTANT: DO NOT EDIT ``.topdeps`` MANUALLY!!! If you do so, you need to
1735 know exactly what you are doing, since this file must stay in sync with
1736 the Git history information, otherwise very bad things will happen.
1738 TopGit also automagically installs a bunch of custom commit-related
1739 hooks that will verify whether you are committing the ``.top*`` files in a
1740 sane state. It will add the hooks to separate files within the ``hooks/``
1741 subdirectory, and merely insert calls to them to the appropriate hooks
1742 and make them executable (but will make sure the original hook's code is
1743 not called if the hook was not executable beforehand).
1745 Another automagically installed piece is a ``.git/info/attributes``
1746 specifier for an ``ours`` merge strategy for the files ``.topmsg`` and
1747 ``.topdeps``, and the (intuitive) ``ours`` merge strategy definition in
1748 ``.git/config``.
1751 REMOTE HANDLING
1752 ---------------
1754 There are two remaining issues with accessing topic branches in remote
1755 repositories:
1757 (i) Referring to remote topic branches from your local repository
1758 (ii) Developing some of the remote topic branches locally
1760 There are two somewhat contradictory design considerations here:
1762 (a) Hacking on multiple independent TopGit remotes in a single
1763 repository
1764 (b) Having a self-contained topic system in local refs space
1766 To us, (a) does not appear to be very convincing, while (b) is quite
1767 desirable for ``git-log topic`` etc. working, and increased conceptual
1768 simplicity.
1770 Thus, we choose to instantiate all the topic branches of given remote
1771 locally; this is performed by ``tg remote --populate``. ``tg update``
1772 will also check if a branch can be updated from its corresponding remote
1773 branch. The logic needs to be somewhat involved if we are to "do the
1774 right thing". First, we update the base, handling the remote branch as
1775 if it was the first dependency; thus, conflict resolutions made in the
1776 remote branch will be carried over to our local base automagically.
1777 Then, the base is merged into the remote branch and the result is merged
1778 to the local branch -- again, to carry over remote conflict resolutions.
1779 In the future, this order might be adjustable on a per-update basis, in
1780 case local changes happen to be diverging more than the remote ones.
1781 (See the details in `The Update Process`_ for more in depth coverage.)
1783 All commands by default refer to the remote that ``tg remote --populate``
1784 was called on the last time (stored in the ``topgit.remote`` git
1785 configuration variable). You can manually run any command with a
1786 different base remote by passing ``-r REMOTE`` *before* the subcommand
1787 name or passing ``-u`` *before* the subcommand to run without one.
1790 TECHNICAL
1791 ---------
1793 A familiarity with the terms in the GLOSSARY_ is helpful for understanding the
1794 content of this sections. See also the IMPLEMENTATION_ section.
1796 The Update Process
1797 ~~~~~~~~~~~~~~~~~~
1799 When a branch is "updated" using the ``tg update`` command the following steps
1800 are taken:
1802 1) The branch and all of its dependencies (and theirs recursively)
1803 are checked to see which ones are *out-of-date*. See glossary_.
1805 2) Each of the branch's direct dependencies (i.e. they are listed in
1806 the branch's ``.topdeps`` file) which is out of date is updated
1807 before proceeding (yup, this is a recursive process).
1809 3) Each of the branch's direct dependencies (i.e. they are listed in
1810 the branch's ``.topdes`` file) that was updated in the previous
1811 step is now merged into the branch's corresponding base. If a
1812 remote is involved, and the branch's corresponding base does NOT
1813 contain the remote branch's corresponding base that remote base is
1814 also merged into the branch's base at this time as well (it will be
1815 the first item merged into the branch's base).
1817 4) If the branch has a corresponding remote branch and the branch
1818 does not already contain it, it's merged into the branch's base
1819 (which was possibly already updated in step (3) to contain the
1820 remote branch's base but not the remote branch itself) on a detached
1821 HEAD. Yup, this step can be a bit confusing and no, the updated
1822 base from step (3) has not yet been merged into the branch itself
1823 yet either. If there is no remote branch this step does not apply.
1824 Using a detached HEAD allows the remote branch to be merged into the
1825 contents of the base without actually perturbing the base's ref.
1827 5) If there is a remote branch present then use the result of step (4)
1828 otherwise use the branch's base and merge that into the branch
1829 itself.
1831 That's it! Simple, right? ;)
1833 Unless the auto stash option has been disabled (see `no undo`_, `tg update`_
1834 and `tg tag`_), a copy of all the old refs values will be stashed away
1835 immediately after step (1) before starting step (2), but only if anything is
1836 actually found to be out-of-date.
1838 Merge Strategies
1839 ~~~~~~~~~~~~~~~~
1841 The ``tg update`` command regularly performs merges while executing an update
1842 operation. In order to speed things up, it attempts to do in-index merges
1843 where possible. It accomplishes this by using a separate, temporary index
1844 file and the ``git read-tree -m --aggressive`` command possibly assisted by
1845 the ``git merge-index`` and ``git merge-file`` commands. This combination may
1846 be repeated more than once to perform an octopus in-index merge. If this
1847 fails, the files are checked out and a normal ``git merge`` three-way merge is
1848 performed (possily multiple times). If the normal ``git merge`` fails then
1849 user intervention is required to resolve the merge conflict(s) and continue.
1851 Since the ``tg annihilate``, ``tg create`` and ``tg depend add`` commands may
1852 end up running the ``tg update`` machinery behind the scenes to complete their
1853 operation they may also result in any of these merge strategies being used.
1855 In addition to the normal Git merge strategies (if the in-index merging fails),
1856 there are four possible TopGit merge strategies that may be shown. Since they
1857 all involve use of the ``git read-tree -m --aggressive`` command they are all
1858 variations of a "trivial aggressive" merge. The "trivial" part because all of
1859 the merges done by ``git read-tree -m`` are described as "trivial" and the
1860 "aggressive" part because the ``--aggressive`` option is always used.
1862 1) "trivial aggressive"
1863 Only two heads were involved and all merging was completed by
1864 the ``git read-tree -m --aggressive`` command.
1866 2) "trivial aggressive automatic"
1867 Only two heads were involved but after the
1868 ``git read-tree -m --aggressive`` command completed there were
1869 still unresolved items and ``git merge-index`` had to be run
1870 (using the ``tg index-merge-one-file`` driver) which ultimately
1871 ran ``git merge-file`` at least once to perform a simple
1872 automatic three-way merge. Hence the "automatic" description
1873 and the "Auto-merging ..." output line(s).
1875 3) "trivial aggressive octopus"
1876 This is the same as a "trivial aggressive" merge except that
1877 more than two heads were involved and after merging the first
1878 two heads, the ``git read-tree -m --aggressive`` step was
1879 repeated again on the result for each additional head. All
1880 merging was completed via multiple
1881 ``git read-tree -m --aggressive`` commands only.
1882 This beast is relatively rare in the wild.
1884 4) "trivial aggressive automatic octopus"
1885 This is very similar to the "trivial aggressive octopus"
1886 except that at least one of the ``git read-tree -m --aggressive``
1887 commands left unresolved items that were handled the same way
1888 as the "trivial aggressive automatic" strategy. This species
1889 is commonly seen in the wild.
1892 GLOSSARY
1893 --------
1895 .topmsg
1896 Version-controlled file stored at the root level of each
1897 TopGit branch that contains the patch header for a TopGit
1898 branch. See also IMPLEMENTATION_;
1900 .topdeps
1901 Version-controlled file stored at the root level of each
1902 TopGit branch that lists the branch's dependencies one per
1903 line omitting the leading ``refs/heads/`` part. See also
1904 IMPLEMENTATION_;
1906 branch containment
1907 Given two Git commit identifiers (e.g. hashes) C1 and C2,
1908 commit C1 "contains" commit C2 if either they are the same
1909 commit or C2 can be reached from C1 by following one or more
1910 parent links from C1 (perhaps via one or more intermediate
1911 commits along the way). In other words, if C1 contains C2
1912 then C2 is an ancestor of C1 or conversely C1 is a descendant
1913 of C2. Since a TopGit branch name is also the name of a Git
1914 branch (something located under the ``refs/heads`` Git
1915 namespace) and similarly for a TopGit base, they can both be
1916 resolved to a Git commit identifier and then participate in
1917 a branch containment test. An easy mnemonic for this is
1918 "children contain the genes of their parents."
1920 contains
1921 See branch containment.
1923 TopGit
1924 Excellent system for managing a history of changes to one
1925 or more possibly interrelated patches.
1927 TopGit branch
1928 A Git branch that has an associated TopGit base. Conceptually
1929 it represents a single patch that is the difference between
1930 the associated TopGit base and the TopGit branch. In other
1931 words ``git diff-tree <TopGit base> <TopGit branch>`` except
1932 that any ``.topdeps`` and/or ``.topmsg`` files are excluded
1933 from the result and the contents of the ``.topmsg`` file from
1934 the TopGit branch is prefixed to the result.
1936 TopGit base
1937 A Git branch that records the base upon which a TopGit branch's
1938 single conceptual "patch" is built. The name of the Git branch
1939 is derived from the TopGit branch name by stripping off the
1940 leading ``refs/heads/`` and appending the correct prefix where
1941 all TopGit bases are stored (typically either
1942 ``refs/top-bases/`` or ``refs/heads/{top-bases}/`` -- the
1943 prefix for any given repository can be shown by using the
1944 ``tg --top-bases`` command and updated using the
1945 ``tg migrate-bases`` command).
1947 All of a TopGit branch's dependencies are merged into the
1948 corresponding TopGit base during a ``tg update`` of a branch.
1950 base
1951 See TopGit base.
1953 TopGit ``[PATCH]`` branch
1954 A TopGit branch whose subject starts with ``[PATCH]``. By
1955 convention these TopGit branches contain a single patch
1956 (equivalent to a single patch file) and have at least one
1957 dependency (i.e. their ``.topdeps`` files are never empty).
1959 TopGit ``[BASE]`` branch
1960 A TopGit branch whose subject starts with ``[BASE]``. By
1961 convention these TopGit branches do not actually contain
1962 any changes and their ``.topdeps`` files are empty. They
1963 are used to control a base dependency that another set of
1964 branches depends on.
1966 TopGit ``[STAGE]`` branch
1967 A TopGit branch whose subject starts with ``[STAGE]``. By
1968 convention these TopGit branches do not actually contain any
1969 changes of their own but do have one or (typically) more
1970 dependencies in their ``.topdeps`` file. These branches are
1971 used to bring together one or (typically) more independent
1972 TopGit ``[PATCH]`` branches into a single branch so that
1973 testing and/or evaluation can be performed on the result.
1975 merge conflict
1976 When merging two (or more) heads that touch the same lines in
1977 the file but in different ways the result is a merge conflict
1978 that requires manual intervention. If a merge conflict occurs
1979 with more than two heads (an octopus merge) it's generally
1980 replaced by multiple three-way merges so that by the time a
1981 user sees a merge conflict needing manual resolution, there
1982 will be only two heads involved.
1984 merge strategy
1985 A Git merge strategy (see the "MERGE STRATEGIES" section of
1986 ``git help merge``) or one of the TopGit `merge strategies`_
1987 used to merge two or more heads.
1989 TopGit merge strategy
1990 See the `Merge Strategies`_ section above for details but
1991 basically these are just in-index merges done using the
1992 ``git read-tree -m --aggressive`` command one or more times
1993 possibily assisted by the ``git merge-index`` and the
1994 ``git merge-file`` commands.
1996 octopus merge
1997 A merge involving more than two heads. Note that if there are
1998 less than three independent heads the resulting merge that
1999 started out as an octopus will end up not actually being an
2000 octopus after all.
2002 out-of-date branch
2003 A TopGit branch is considered to be "out-of-date" when ANY of
2004 the following are true:
2006 a) The TopGit branch does NOT contain its
2007 corresponding base.
2009 b) The TopGit branch does NOT contain its
2010 corresponding remote branch (there may not be
2011 a remote branch in which case this does not apply)
2013 c) The TopGit branch's base does NOT contain its
2014 corresponding remote branch's base (there may not be
2015 a remote branch in which case this does not apply)
2017 d) Any of the TopGit branches listed in the branch's
2018 ``.topdeps`` file are NOT contained by the branch.
2019 (See "branch containment" above.)
2021 e) Any of the TopGit branches listed in the branch's
2022 ``.topdeps`` file are out-of-date.
2024 Note that if a remote branch is present and is NOT out-of-date
2025 then it will contain its own base and (c) is mostly redundant.
2027 remote TopGit branch
2028 A Git branch with the same branch name as a TopGit branch
2029 but living under ``refs/remotes/<some remote>/`` instead
2030 of just ``refs/heads/``.
2032 remote TopGit base
2033 The TopGit base branch corresponding to a remote TopGit branch,
2034 which lives under ``refs/remotes/`` somewhere (depending on
2035 what the output of ``tg --top-bases`` is for that remote).
2037 three-way merge
2038 A three-way merge takes a common base and two heads (call them
2039 A and B) and creates a new file that is the common base plus
2040 all of the changes made between the common base and head A
2041 *AND* all of the changes made between the common base and
2042 head B. The technique used to accomplish this is called a
2043 "merge strategy".
2046 REFERENCES
2047 ----------
2049 The following references are useful to understand the development of
2050 topgit and its subcommands.
2052 * tg depend:
2053 http://public-inbox.org/git/36ca99e90904091034m4d4d31dct78acb333612e678@mail.gmail.com/T/#u
2056 THIRD-PARTY SOFTWARE
2057 --------------------
2059 The following software understands TopGit branches:
2061 * `magit <http://magit.github.io/>`_ -- a git mode for emacs
2063 IMPORTANT: Magit requires its topgit mode to be enabled first, as
2064 described in its documentation, in the "Activating extensions"
2065 subsection. If this is not done, it will not push TopGit branches
2066 correctly, so it's important to enable it even if you plan to mostly use
2067 TopGit from the command line.