1 TopGit - A different patch queue manager
7 TopGit aims to make handling of large amount of interdependent topic
8 branches easier. In fact, it is designed especially for the case
9 when you maintain a queue of third-party patches on top of another
10 (perhaps Git-controlled) project and want to easily organize, maintain
11 and submit them - TopGit achieves that by keeping a separate topic
12 branch for each patch and providing few tools to maintain the branches.
18 Why not use something like StGIT or Guilt or rebase -i for maintaining
19 your patch queue? The advantage of these tools is their simplicity;
20 they work with patch _series_ and defer to the reflog facility for
21 version control of patches (reordering of patches is not
22 version-controlled at all). But there are several disadvantages -
23 for one, these tools (especially StGIT) do not actually fit well
24 with plain Git at all: it is basically impossible to take advantage
25 of the index effectively when using StGIT. But more importantly,
26 these tools horribly fail in the face of distributed environment.
28 TopGit has been designed around three main tenets:
30 (i) TopGit is as thin layer on top of Git as possible.
31 You still maintain your index and commit using Git, TopGit will
32 only automate few indispensable tasks.
34 (ii) TopGit is anxious about _keeping_ your history. It will
35 never rewrite your history and all metadata is also tracked by Git,
36 smoothly and non-obnoxiously. It is good to have a _single_ point
37 when the history is cleaned up, and that is at the point of inclusion
38 in the upstream project; locally, you can see how your patch has evolved
39 and easily return to older versions.
41 (iii) TopGit is specifically designed to work in distributed
42 environment. You can have several instances of TopGit-aware repositories
43 and smoothly keep them all up-to-date and transfer your changes between
46 As mentioned above, the main intended use-case for TopGit is tracking
47 third-party patches, where each patch is effectively a single topic
48 branch. In order to flexibly accommodate even complex scenarios when
49 you track many patches where many are independent but some depend
50 on others, TopGit ignores the ancient Quilt heritage of patch series
51 and instead allows the patches to freely form graphs (DAGs just like
52 Git history itself, only "one level higher"). For now, you have
53 to manually specify which patches does the current one depend
54 on, but TopGit might help you with that in the future in a darcs-like
57 A glossary plug: The union (i.e. merge) of patch dependencies is
58 called a _base_ of the patch (topic branch).
60 Of course, TopGit is perhaps not the right tool for you:
62 (i) TopGit is not complicated, but StGIT et al. are somewhat
63 simpler, conceptually. If you just want to make a linear purely-local
64 patch queue, deferring to StGIT instead might make more sense.
66 (ii) When using TopGit, your history can get a little hairy
67 over time, especially with all the merges rippling through. ;-)
73 ## Create and evolve a topic branch
74 $ tg create t/gitweb/pathinfo-action
75 tg: Automatically marking dependency on master
76 tg: Creating t/gitweb/pathinfo-action base from master...
82 ## Create another topic branch on top of the former one
83 $ tg create t/gitweb/nifty-links
84 tg: Automatically marking dependency on t/gitweb/pathinfo-action
85 tg: Creating t/gitweb/nifty-links base from t/gitweb/pathinfo-action...
89 ## Create another topic branch on top of master and submit
90 ## the resulting patch upstream
91 $ tg create t/revlist/author-fixed master
92 tg: Creating t/revlist/author-fixed base from master...
96 tg: Sent t/revlist/author-fixed
98 To: git@vger.kernel.org
100 Subject: [PATCH] Fix broken revlist --author when --fixed-string
102 ## Create another topic branch depending on two others non-trivially
103 $ tg create t/whatever t/revlist/author-fixed t/gitweb/nifty-links
104 tg: Creating t/whatever base from t/revlist/author-fixed...
105 tg: Merging t/whatever base with t/gitweb/nifty-links...
107 tg: Please commit merge resolution and call: tg create
108 tg: It is also safe to abort this operation using `git reset --hard`
109 tg: but please remember you are on the base branch now;
110 tg: you will want to switch to a different branch.
114 tg: Resuming t/whatever setup...
118 ## Update a single topic branch and propagate the changes to
120 $ git checkout t/gitweb/nifty-links
123 $ git checkout t/whatever
125 Topic Branch: t/whatever (1 commit)
126 Subject: [PATCH] Whatever patch
128 Depends: t/revlist/author-fixed t/gitweb/nifty-links
130 t/gitweb/nifty-links (1 commit)
132 tg: Updating base with t/gitweb/nifty-links changes...
134 tg: Please commit merge resolution and call `tg update` again.
135 tg: It is also safe to abort this operation using `git reset --hard`,
136 tg: but please remember you are on the base branch now;
137 tg: you will want to switch to a different branch.
141 tg: Updating t/whatever against new base...
143 tg: Please resolve the merge and commit. No need to do anything else.
144 tg: You can abort this operation using `git reset --hard` now
145 tg: and retry this merge later using `tg update`.
149 ## Update a single topic branch and propagate the changes
150 ## further through the dependency chain
151 $ git checkout t/gitweb/pathinfo-action
154 $ git checkout t/whatever
156 Topic Branch: t/whatever (1/2 commits)
157 Subject: [PATCH] Whatever patch
159 Depends: t/revlist/author-fixed t/gitweb/nifty-links
161 t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
163 tg: Recursing to t/gitweb/nifty-links...
164 [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
166 [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update` again.
167 [t/gitweb/nifty-links] tg: It is also safe to abort this operation using `git reset --hard`,
168 [t/gitweb/nifty-links] tg: but please remember you are on the base branch now;
169 [t/gitweb/nifty-links] tg: you will want to switch to a different branch.
170 [t/gitweb/nifty-links] tg: You are in a subshell. If you abort the merge,
171 [t/gitweb/nifty-links] tg: use `exit` to abort the recursive update altogether.
172 [t/gitweb/nifty-links] $ ..resolve..
173 [t/gitweb/nifty-links] $ git commit
174 [t/gitweb/nifty-links] $ tg update
175 [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base...
177 [t/gitweb/nifty-links] tg: Please resolve the merge and commit.
178 [t/gitweb/nifty-links] tg: You can abort this operation using `git reset --hard`.
179 [t/gitweb/nifty-links] tg: You are in a subshell. After you either commit or abort
180 [t/gitweb/nifty-links] tg: your merge, use `exit` to proceed with the recursive update.
181 [t/gitweb/nifty-links] $ ..resolve..
182 [t/gitweb/nifty-links] $ git commit
183 [t/gitweb/nifty-links] $ exit
184 tg: Updating base with t/gitweb/nifty-links changes...
185 tg: Updating t/whatever against new base...
187 ## Clone a TopGit-controlled repository
190 $ tg remote --populate origin
195 ## Add a TopGit remote to a repository and push to it
196 $ git remote add foo URL
200 ## Update from a non-default TopGit remote
209 The 'tg' tool of TopGit has several subcommands:
213 Our sophisticated integrated help facility. Doesn't do
218 Create a new TopGit-controlled topic branch of a given name
219 (required argument) and switch to it. If no dependencies
220 are specified (by extra arguments passed after the first one),
221 the current branch is assumed to be the only dependency.
223 After `tg create`, you should insert the patch description
224 to the '.topmsg' file, which will already contain some
225 prefilled bits. You can set topgit.to, topgit.cc and topgit.bcc
226 configuration variables in order to have `tg create`
227 add these headers with given default values to '.topmsg'.
229 The main task of `tg create` is to set up the topic branch
230 base from the dependencies. This may fail due to merge conflicts.
231 In that case, after you commit the conflicts resolution,
232 you should call `tg create` again (without any arguments);
233 it will detect that you are on a topic branch base ref and
234 resume the topic branch creation operation.
236 In an alternative use case, if '-r BRANCH' is given instead
237 of dependency list, the topic branch is created based on
238 the given remote branch.
242 Remove a TopGit-controlled topic branch of given name
243 (required argument). Normally, this command will remove
244 only empty branch (base == head); use '-f' to remove
247 The '-f' option is also useful to force removal of a branch's base, if
248 you used 'git branch -D B' to remove the branch B, and then certain
249 TopGit commands complain, because the base of branch B is still there.
251 Currently, this command will _NOT_ remove the branch from
252 the dependency list in other branches. You need to take
253 care of this _manually_. This is even more complicated
254 in combination with '-f', in that case you need to manually
255 unmerge the removed branch's changes from the branches
258 TODO: '-a' to delete all empty branches, depfix, revert
262 Change dependencies of a TopGit-controlled topic branch.
263 This should have several subcommands, but only 'add' is
266 The 'add' subcommand takes an argument of a topic branch
267 to be added, adds it to '.topdeps', performs a commit and
268 then updates your topic branch accordingly. If you want to
269 do other things related to the dependency addition, like
270 adjusting '.topmsg', prepare them in the index before
271 calling 'tg depend add'.
273 TODO: Subcommand for removing dependencies, obviously
277 List files changed by the current or specified topic branch.
280 -i list files based on index instead of branch
281 -w list files based on working tree instead of branch
285 Show a summary information about the current or specified
290 Generate a patch from the current or specified topic branch.
291 This means that the diff between the topic branch base and
292 head (latest commit) is shown, appended to the description
293 found in the .topmsg file.
295 The patch is by default simply dumped to stdout. In the future,
296 tg patch will be able to automatically send the patches by mail
297 or save them to files. (TODO)
300 -i base patch generation on index instead of branch
301 -w base patch generation on working tree instead of branch
305 Send a patch from the current or specified topic branch as
308 Takes the patch given on the command line and emails it out.
309 Destination addresses such as To, Cc and Bcc are taken from the
312 Since it actually boils down to `git send-email` please refer to
313 its documentation for details on how to setup email for git.
314 You can pass arbitrary options to this command through the
315 '-s' parameter, but you must double-quote everything.
316 The '-r' parameter with msgid can be used to generate in-reply-to
317 and reference headers to an earlier mail.
319 Note: be careful when using this command. It easily sends out several
320 mails. You might want to run
322 git config sendemail.confirm always
324 to let `git send-email` ask for confirmation before sending any mail.
327 -i base patch generation on index instead of branch
328 -w base patch generation on working tree instead of branch
330 TODO: 'tg mail patchfile' to mail an already exported patch
331 TODO: mailing patch series
332 TODO: specifying additional options and addresses on command
337 Register given remote as TopGit-controlled. This will create
338 the namespace for the remote branch bases and teach 'git fetch'
339 and 'git push' to operate on them. (Do NOT use 'git push --all'
340 for your pushes - plain 'git push' will do the right thing.)
342 It takes a optional remote name argument, and optional
343 '--populate' switch - use that for your origin-style remote,
344 it will seed the local topic branch system based on the
345 remote topic branches. '--populate' will also make 'tg remote'
346 automatically fetch the remote and 'tg update' to look at
347 branches of this remote for updates by default.
351 Show overview of all TopGit-tracked topic branches and their
352 up-to-date status ('>' marks the current topic branch,
353 '0' marks that it introduces no own changes,
354 'l'/'r' marks that it is local-only or has remote mate,
355 'L'/'R' marks that it is ahead/out-of-date wrt. its remote mate,
356 'D' marks that it is out-of-date wrt. its dependencies,
357 '!' marks that it has missing dependencies (even recursively),
358 'B' marks that it is out-of-date wrt. its base).
360 This can take long time to accurately determine all the relevant
361 information about each branch; you can pass '-t' to get just
362 terse list of topic branch names quickly. Alternately, you can
363 pass '--graphviz' to get a dot-suitable output to draw a dependency
364 graph between the topic branches.
366 You can also use the --sort option to sort the branches using
367 a topological sort. This is especially useful if each
368 TopGit-tracked topic branch depends on a single parent branch,
369 since it will then print the branches in the dependency
370 order. In more complex scenarios, a text graph view would be
371 much more useful, but that is not yet implemented.
373 The --deps option outputs dependency informations between
374 branches in a machine-readable format. Feed this to "tsort"
375 to get the output from --sort.
378 -i Use TopGit meta data from the index instead of branch
379 -w Use TopGit meta data from the working tree instead of branch
381 TODO: Speed up by an order of magnitude
382 TODO: Text graph view
386 Export a tidied-up history of the current topic branch
387 and its dependencies, suitable for feeding upstream.
388 Each topic branch corresponds to a single commit or patch
389 in the cleaned up history (corresponding basically exactly
390 to `tg patch` output for the topic branch).
392 The command has three possible outputs now - either a Git branch with
393 the collapsed history, a Git branch with a linearized history, or a
394 quilt series in new directory.
396 In case of producing collapsed history in new branch,
397 you can use this collapsed structure either for providing
398 a pull source for upstream, or further linearization e.g.
399 for creation of a quilt series using git log:
401 git log --pretty=email -p --topo-order origin..exported
403 To better understand the function of `tg export`,
404 consider this dependency structure of topic branches:
406 origin/master - t/foo/blue - t/foo/red - master
407 `- t/bar/good <,----------'
408 `- t/baz ------------'
410 (Where each of the branches may have hefty history.) Then
412 master$ tg export for-linus
414 will create this commit structure on branch for-linus:
416 origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
417 `- t/bar/good <,-------------------'/
418 `- t/baz ---------------------'
420 In case of using the linearize mode:
422 master$ tg export --linearize for-linus
424 you get a linear history respecting the dependencies of your patches in
425 a new branch for-linus. The result should be more or less the same as
426 using quilt mode and reimporting it into a Git branch. (More or less
427 because the topologic order can usually be extended in more than one
428 way into a complete ordering and the two methods may choose different
429 one's.) The result might be more appropriate for merging upstream as
430 it contains fewer merges.
432 Note that you might get conflicts during linearization because the
433 patches are reordered to get a linear history.
435 In case of the quilt mode,
437 master$ tg export --quilt for-linus
439 would create this directory for-linus:
441 for-linus/t/foo/blue.diff
442 for-linus/t/foo/red.diff
443 for-linus/t/bar/good.diff
451 The command works on the current topic branch
452 and can be called either without a parameter
453 (in that case, '--collapse' is assumed)
454 and with one mandatory argument: the name of the branch
455 where the exported result shall be stored.
456 The branch will be silently overwritten if it exists already!
457 Use git reflog to recover in case of mistake.
459 Alternatively, call it with the '--quilt' parameter
460 and an argument specifying the directory
461 where the quilt series should be saved.
463 With '--quilt', you can also pass '-b' parameter followed by
464 a comma-separated explicit list of branches to export. This
465 mode of operation is currently not supported with collapse.
467 In '--quilt' mode the patches are named like the originating topgit
468 branch. So usually they end up in subdirectories of the output
469 directory. With option '--flatten' the names are mangled such that
470 they end up directly in the output dir (i.e. slashed are substituted by
471 underscores). With '--numbered' (which implies '--flatten') the patch
472 names get a number as prefix to allow getting the order without
473 consulting the series file, which eases sending out the patches.
475 Usage: tg export ([(--collapse | --linearize)] BRANCH | --quilt DIR)
477 TODO: Make stripping of non-essential headers configurable
478 TODO: Make stripping of [PATCH] and other prefixes configurable
479 TODO: --mbox option for other mode of operation
480 TODO: -a option to export all branches
481 TODO: For quilt exporting, export the linearized history created in a
482 temporary branch---this would allow producing conflict-less
487 Import commits within the given revision range into TopGit,
488 creating one topic branch per commit, the dependencies forming
489 a linear sequence starting on your current branch (or a branch
490 specified by the '-d' parameter).
492 The branch names are auto-guessed from the commit messages
493 and prefixed by t/ by default; use '-p PREFIX' to specify
494 an alternative prefix (even an empty one).
496 Alternatively, you can use the '-s NAME' parameter to specify
497 the name of target branch; the command will then take one more
498 argument describing a single commit to import.
502 Update the current or specified topic branch wrt. changes in the
503 branches it depends on and remote branches.
504 This is performed in two phases - first,
505 changes within the dependencies are merged to the base,
506 then the base is merged into the topic branch.
507 The output will guide you in case of conflicts.
509 After the update the current branch is the specified one.
511 In case your dependencies are not up-to-date, tg update
512 will first recurse into them and update these.
514 If a remote branch update brings dependencies on branches
515 not yet instantiated locally, you can either bring in all
516 the new branches from the remote using 'tg remote --populate'
517 or only pick out the missing ones using 'tg create -r'
518 ('tg summary' will point out branches with incomplete
519 dependencies by showing an '!' near to them).
521 TODO: tg update -a for updating all topic branches
525 pushes a TopGit-controlled topic branch to a remote
526 repository. By default the remote gets all dependencies
527 (both tgish and non-tgish) and bases pushed to.
531 Prints the base commit of the current topic branch. Silently
532 exits with exit code 1 if you are not working on a TopGit
537 Prints the git log of the named topgit branch.
539 Note: if you have merged changes from a different repository, this
540 command might not list all interesting commits.
544 Outputs the direct dependencies for the current or named patch.
547 -i show dependencies based on index instead of branch
548 -w show dependencies based on working tree instead of branch
552 Outputs all patches which directly depend on the current or
556 -i show dependencies based on index instead of branch
557 -w show dependencies based on working tree instead of branch
564 TopGit stores all the topic branches in the regular refs/heads/
565 namespace, (we recommend to mark them with the 't/' prefix).
566 Except that, TopGit also maintains a set of auxiliary refs in
567 refs/top-*. Currently, only refs/top-bases/ is used, containing
568 the current _base_ of the given topic branch - this is basically
569 a merge of all the branches the topic branch depends on; it is
570 updated during `tg update` and then merged to the topic branch,
571 and it is the base of a patch generated from the topic branch by
574 All the metadata is tracked within the source tree and history
575 of the topic branch itself, in .top* files; these files are kept
576 isolated within the topic branches during TopGit-controlled merges
577 and are of course omitted during `tg patch`. The state of these
578 files in base commits is undefined; look at them only in the topic
579 branches themselves. Currently, two files are defined:
581 .topmsg: Contains the description of the topic branch
582 in a mail-like format, plus the author information,
583 whatever Cc headers you choose or the post-three-dashes message.
584 When mailing out your patch, basically only few extra headers
585 mail headers are inserted and the patch itself is appended.
586 Thus, as your patches evolve, you can record nuances like whether
587 the particular patch should have To-list/Cc-maintainer or vice
588 versa and similar nuances, if your project is into that.
589 From is prefilled from your current GIT_AUTHOR_IDENT, other headers
590 can be prefilled from various optional topgit.* config options.
592 .topdeps: Contains the one-per-line list of branches
593 your patch depends on, pre-seeded with `tg create`. (Continuously
594 updated) merge of these branches will be the "base" of your topic
595 branch. DO NOT EDIT THIS FILE MANUALLY!!! If you do so, you need
596 to know exactly what are you doing, since this file must stay in
597 sync with the Git history information, otherwise very bad things
600 TopGit also automagically installs a bunch of custom commit-related
601 hooks that will verify if you are committing the .top* files in sane
602 state. It will add the hooks to separate files within the hooks/
603 subdirectory and merely insert calls of them to the appropriate hooks
604 and make them executable (but make sure the original hooks code
605 is not called if the hook was not executable beforehand).
607 Another automagically installed piece is .git/info/attributes specifier
608 for an 'ours' merge strategy for the files .topmsg and .topdeps, and
609 the (intuitive) 'ours' merge strategy definition in .git/config.
615 There are three issues with accessing topic branches in remote repositories:
617 (i) Fetching/pushing accurate picture of the remote topic branch setup
618 (ii) Referring to remote topic branches from your local repository
619 (iii) Developing some of the remote topic branches locally
621 (ii) and (iii) are fairly interconnected problems, while (i) is largely
622 independent. The issue is to accurately reflect the current state of the
623 quickly changing topic branches set - this can be easily done
624 with the current facilities like 'git remote prune' and 'git push --mirror' -
625 and to properly upload also the bases of the topic branches.
626 For this, we need to modify the fetch/push refspecs to also include
627 the refs/top-bases/ ref namespace; we shall provide a special 'tg remote'
628 command to set up an existing remote for TopGit usage.
630 About (ii) and (iii), there are two somewhat contradicting design
633 (a) Hacking on multiple independent TopGit remotes in a single
635 (b) Having a self-contained topic system in local refs space
637 To us, (a) does not appear to be very convincing, while (b) is quite desirable
638 for 'git-log topic' etc. working, 'git push' automatically creating
639 self-contained topic system in the remote repository, and increased conceptual
642 Thus, we choose to instantiate all the topic branches of given remote locally;
643 this is performed by 'tg remote --populate'.
644 'tg update' will also check if a branch can be updated from its corresponding
645 remote branch. The logic is somewhat involved if we should DTRT.
646 First, we update the base, handling the remote branch as if it was the first
647 dependency; thus, conflict resolutions made in the remote branch will be
648 carried over to our local base automagically. Then, the base is merged into
649 remote branch and the result is merged to local branch - again, to carry over
650 remote conflict resolutions. In the future, this order might be adjustable
651 per-update in case local changes are diverging more than the remote ones.
653 All commands by default refer to the remote that 'tg remote --populate'
654 was called on the last time ('topgit.remote' configuration variable). You can
655 manually run any command with a different base remote by passing '-r REMOTE'
656 _before_ the subcommand name.
662 The following references are useful to understand the development of topgit and
666 http://lists-archives.org/git/688698-add-list-and-rm-sub-commands-to-tg-depend.html