chiark / gitweb /
fa9d63f74dcb97bf3e4c4ca1a6470be9de0a9676
[topgit.git] / README
1 TopGit - A different patch queue manager
2
3
4 DESCRIPTION
5 -----------
6
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.
13
14
15 RATIONALE
16 ---------
17
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.
27
28 TopGit has been designed around three main tenets:
29
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.
33
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.
40
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
44 them.
45
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
55 fashion.
56
57 A glossary plug: The union (i.e. merge) of patch dependencies is
58 called a _base_ of the patch (topic branch).
59
60 Of course, TopGit is perhaps not the right tool for you:
61
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.
65
66         (ii) When using TopGit, your history can get a little hairy
67 over time, especially with all the merges rippling through. ;-)
68
69
70 SYNOPSIS
71 --------
72
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...
77         $ ..hack..
78         $ git commit
79         $ ..fix a mistake..
80         $ git commit
81
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...
86         $ ..hack..
87         $ git commit
88
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...
93         $ ..hack..
94         $ git commit
95         $ tg patch -m
96         tg: Sent t/revlist/author-fixed
97         From: pasky@suse.cz
98         To: git@vger.kernel.org
99         Cc: gitster@pobox.com
100         Subject: [PATCH] Fix broken revlist --author when --fixed-string
101
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...
106         Merge failed!
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.
111         $ ..resolve..
112         $ git commit
113         $ tg create
114         tg: Resuming t/whatever setup...
115         $ ..hack..
116         $ git commit
117
118         ## Update a single topic branch and propagate the changes to
119         ## a different one
120         $ git checkout t/gitweb/nifty-links
121         $ ..hack..
122         $ git commit
123         $ git checkout t/whatever
124         $ tg info
125         Topic Branch: t/whatever (1 commit)
126         Subject: [PATCH] Whatever patch
127         Base: 3f47ebc1
128         Depends: t/revlist/author-fixed t/gitweb/nifty-links
129         Needs update from:
130                 t/gitweb/nifty-links (1 commit)
131         $ tg update
132         tg: Updating base with t/gitweb/nifty-links changes...
133         Merge failed!
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.
138         $ ..resolve..
139         $ git commit
140         $ tg update
141         tg: Updating t/whatever against new base...
142         Merge failed!
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`.
146         $ ..resolve..
147         $ git commit
148
149         ## Update a single topic branch and propagate the changes
150         ## further through the dependency chain
151         $ git checkout t/gitweb/pathinfo-action
152         $ ..hack..
153         $ git commit
154         $ git checkout t/whatever
155         $ tg info
156         Topic Branch: t/whatever (1/2 commits)
157         Subject: [PATCH] Whatever patch
158         Base: 0ab2c9b3
159         Depends: t/revlist/author-fixed t/gitweb/nifty-links
160         Needs update from:
161                 t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit)
162         $ tg update
163         tg: Recursing to t/gitweb/nifty-links...
164         [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes...
165         Merge failed!
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...
176         Merge failed!
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...
186
187         ## Clone a TopGit-controlled repository
188         $ git clone URL repo
189         $ cd repo
190         $ tg remote --populate origin
191         ...
192         $ git fetch
193         $ tg update
194
195         ## Add a TopGit remote to a repository and push to it
196         $ git remote add foo URL
197         $ tg remote foo
198         $ git push foo
199
200         ## Update from a non-default TopGit remote
201         $ git fetch foo
202         $ tg -r foo summary
203         $ tg -r foo update
204
205
206 USAGE
207 -----
208
209 The 'tg' tool of TopGit has several subcommands:
210
211 tg help
212 ~~~~~~~
213         Our sophisticated integrated help facility. Doesn't do
214         a whole lot for now.
215
216 tg create
217 ~~~~~~~~~
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.
222
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'.
228
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.
235
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.
239
240 tg delete
241 ~~~~~~~~~
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
245         non-empty branch.
246
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.
250
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
256         depending on it.
257
258         TODO: '-a' to delete all empty branches, depfix, revert
259
260 tg depend
261 ~~~~~~~~~
262         Change dependencies of a TopGit-controlled topic branch.
263         This should have several subcommands, but only 'add' is
264         supported right now.
265
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'.
272
273         TODO: Subcommand for removing dependencies, obviously
274
275 tg files
276 ~~~~~~~~
277         List files changed by the current or specified topic branch.
278
279         Options:
280           -i            list files based on index instead of branch
281           -w            list files based on working tree instead of branch
282
283 tg info
284 ~~~~~~~
285         Show a summary information about the current or specified
286         topic branch.
287
288 tg patch
289 ~~~~~~~~
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.
294
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)
298
299         Options:
300           -i            base patch generation on index instead of branch
301           -w            base patch generation on working tree instead of branch
302
303 tg mail
304 ~~~~~~~
305         Send a patch from the current or specified topic branch as
306         email.
307
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
310         patch header.
311
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.
318
319         Note: be careful when using this command.  It easily sends out several
320         mails.  You might want to run
321
322                 git config sendemail.confirm always
323
324         to let `git send-email` ask for confirmation before sending any mail.
325
326         TODO: 'tg mail patchfile' to mail an already exported patch
327         TODO: mailing patch series
328         TODO: specifying additional options and addresses on command
329               line
330
331 tg remote
332 ~~~~~~~~~
333         Register given remote as TopGit-controlled. This will create
334         the namespace for the remote branch bases and teach 'git fetch'
335         and 'git push' to operate on them. (Do NOT use 'git push --all'
336         for your pushes - plain 'git push' will do the right thing.)
337
338         It takes a optional remote name argument, and optional
339         '--populate' switch - use that for your origin-style remote,
340         it will seed the local topic branch system based on the
341         remote topic branches. '--populate' will also make 'tg remote'
342         automatically fetch the remote and 'tg update' to look at
343         branches of this remote for updates by default.
344
345 tg summary
346 ~~~~~~~~~~
347         Show overview of all TopGit-tracked topic branches and their
348         up-to-date status ('>' marks the current topic branch,
349         '0' marks that it introduces no own changes,
350         'l'/'r' marks that it is local-only or has remote mate,
351         'L'/'R' marks that it is ahead/out-of-date wrt. its remote mate,
352         'D' marks that it is out-of-date wrt. its dependencies,
353         '!' marks that it has missing dependencies (even recursively),
354         'B' marks that it is out-of-date wrt. its base).
355
356         This can take long time to accurately determine all the relevant
357         information about each branch; you can pass '-t' to get just
358         terse list of topic branch names quickly. Alternately, you can
359         pass '--graphviz' to get a dot-suitable output to draw a dependency
360         graph between the topic branches.
361
362         You can also use the --sort option to sort the branches using
363         a topological sort.  This is especially useful if each
364         TopGit-tracked topic branch depends on a single parent branch,
365         since it will then print the branches in the dependency
366         order.  In more complex scenarios, a text graph view would be
367         much more useful, but that is not yet implemented.
368
369         The --deps option outputs dependency informations between
370         branches in a machine-readable format.  Feed this to "tsort"
371         to get the output from --sort.
372
373         Options:
374           -i            Use TopGit meta data from the index instead of branch
375           -w            Use TopGit meta data from the working tree instead of branch
376
377         TODO: Speed up by an order of magnitude
378         TODO: Text graph view
379
380 tg export
381 ~~~~~~~~~
382         Export a tidied-up history of the current topic branch
383         and its dependencies, suitable for feeding upstream.
384         Each topic branch corresponds to a single commit or patch
385         in the cleaned up history (corresponding basically exactly
386         to `tg patch` output for the topic branch).
387
388         The command has three possible outputs now - either a Git branch with
389         the collapsed history, a Git branch with a linearized history, or a
390         quilt series in new directory.
391
392         In case of producing collapsed history in new branch,
393         you can use this collapsed structure either for providing
394         a pull source for upstream, or further linearization e.g.
395         for creation of a quilt series using git log:
396
397                 git log --pretty=email -p --topo-order origin..exported
398
399         To better understand the function of `tg export`,
400         consider this dependency structure of topic branches:
401
402         origin/master - t/foo/blue - t/foo/red - master
403                      `- t/bar/good <,----------'
404                      `- t/baz      ------------'
405
406         (Where each of the branches may have hefty history.) Then
407
408         master$ tg export for-linus
409
410         will create this commit structure on branch for-linus:
411
412         origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master
413                      `- t/bar/good <,-------------------'/
414                      `- t/baz      ---------------------'
415
416         In case of using the linearize mode:
417
418         master$ tg export --linearize for-linus
419
420         you get a linear history respecting the dependencies of your patches in
421         a new branch for-linus.  The result should be more or less the same as
422         using quilt mode and reimporting it into a Git branch.  (More or less
423         because the topologic order can usually be extended in more than one
424         way into a complete ordering and the two methods may choose different
425         one's.)  The result might be more appropriate for merging upstream as
426         it contains fewer merges.
427
428         Note that you might get conflicts during linearization because the
429         patches are reordered to get a linear history.
430
431         In case of the quilt mode,
432
433         master$ tg export --quilt for-linus
434
435         would create this directory for-linus:
436
437         for-linus/t/foo/blue.diff
438         for-linus/t/foo/red.diff
439         for-linus/t/bar/good.diff
440         for-linus/t/baz.diff
441         for-linus/series:
442                 t/foo/blue.diff -p1
443                 t/bar/good.diff -p1
444                 t/foo/red.diff -p1
445                 t/baz.diff -p1
446
447         The command works on the current topic branch
448         and can be called either without a parameter
449         (in that case, '--collapse' is assumed)
450         and with one mandatory argument: the name of the branch
451         where the exported result shall be stored.
452         The branch will be silently overwritten if it exists already!
453         Use git reflog to recover in case of mistake.
454
455         Alternatively, call it with the '--quilt' parameter
456         and an argument specifying the directory
457         where the quilt series should be saved.
458
459         With '--quilt', you can also pass '-b' parameter followed by
460         a comma-separated explicit list of branches to export. This
461         mode of operation is currently not supported with collapse.
462
463         In '--quilt' mode the patches are named like the originating topgit
464         branch.  So usually they end up in subdirectories of the output
465         directory.  With option '--flatten' the names are mangled such that
466         they end up directly in the output dir (i.e. slashed are substituted by
467         underscores).  With '--numbered' (which implies '--flatten') the patch
468         names get a number as prefix to allow getting the order without
469         consulting the series file, which eases sending out the patches.
470
471         Usage: tg export ([(--collapse | --linearize)] BRANCH | --quilt DIR)
472
473         TODO: Make stripping of non-essential headers configurable
474         TODO: Make stripping of [PATCH] and other prefixes configurable
475         TODO: --mbox option for other mode of operation
476         TODO: -a option to export all branches
477         TODO: For quilt exporting, export the linearized history created in a
478               temporary branch---this would allow producing conflict-less
479               series
480
481 tg import
482 ~~~~~~~~~
483         Import commits within the given revision range into TopGit,
484         creating one topic branch per commit, the dependencies forming
485         a linear sequence starting on your current branch (or a branch
486         specified by the '-d' parameter).
487
488         The branch names are auto-guessed from the commit messages
489         and prefixed by t/ by default; use '-p PREFIX' to specify
490         an alternative prefix (even an empty one).
491
492         Alternatively, you can use the '-s NAME' parameter to specify
493         the name of target branch; the command will then take one more
494         argument describing a single commit to import.
495
496 tg update
497 ~~~~~~~~~
498         Update the current or specified topic branch wrt. changes in the
499         branches it depends on and remote branches.
500         This is performed in two phases - first,
501         changes within the dependencies are merged to the base,
502         then the base is merged into the topic branch.
503         The output will guide you in case of conflicts.
504
505         After the update the current branch is the specified one.
506
507         In case your dependencies are not up-to-date, tg update
508         will first recurse into them and update these.
509
510         If a remote branch update brings dependencies on branches
511         not yet instantiated locally, you can either bring in all
512         the new branches from the remote using 'tg remote --populate'
513         or only pick out the missing ones using 'tg create -r'
514         ('tg summary' will point out branches with incomplete
515         dependencies by showing an '!' near to them).
516
517         TODO: tg update -a for updating all topic branches
518
519 tg push
520 ~~~~~~~
521         pushes a TopGit-controlled topic branch to a remote
522         repository.  By default the remote gets all dependencies
523         (both tgish and non-tgish) and bases pushed to.
524
525 tg base
526 ~~~~~~~
527         Prints the base commit of the current topic branch.  Silently
528         exits with exit code 1 if you are not working on a TopGit
529         branch.
530
531 tg log
532 ~~~~~~
533         Prints the git log of the named topgit branch.
534
535         Note: if you have merged changes from a different repository, this
536         command might not list all interesting commits.
537
538 TODO: tg rename
539
540
541 IMPLEMENTATION
542 --------------
543
544 TopGit stores all the topic branches in the regular refs/heads/
545 namespace, (we recommend to mark them with the 't/' prefix).
546 Except that, TopGit also maintains a set of auxiliary refs in
547 refs/top-*. Currently, only refs/top-bases/ is used, containing
548 the current _base_ of the given topic branch - this is basically
549 a merge of all the branches the topic branch depends on; it is
550 updated during `tg update` and then merged to the topic branch,
551 and it is the base of a patch generated from the topic branch by
552 `tg patch`.
553
554 All the metadata is tracked within the source tree and history
555 of the topic branch itself, in .top* files; these files are kept
556 isolated within the topic branches during TopGit-controlled merges
557 and are of course omitted during `tg patch`. The state of these
558 files in base commits is undefined; look at them only in the topic
559 branches themselves.  Currently, two files are defined:
560
561         .topmsg: Contains the description of the topic branch
562 in a mail-like format, plus the author information,
563 whatever Cc headers you choose or the post-three-dashes message.
564 When mailing out your patch, basically only few extra headers
565 mail headers are inserted and the patch itself is appended.
566 Thus, as your patches evolve, you can record nuances like whether
567 the particular patch should have To-list/Cc-maintainer or vice
568 versa and similar nuances, if your project is into that.
569 From is prefilled from your current GIT_AUTHOR_IDENT, other headers
570 can be prefilled from various optional topgit.* config options.
571
572         .topdeps: Contains the one-per-line list of branches
573 your patch depends on, pre-seeded with `tg create`. (Continuously
574 updated) merge of these branches will be the "base" of your topic
575 branch. DO NOT EDIT THIS FILE MANUALLY!!! If you do so, you need
576 to know exactly what are you doing, since this file must stay in
577 sync with the Git history information, otherwise very bad things
578 will happen.
579
580 TopGit also automagically installs a bunch of custom commit-related
581 hooks that will verify if you are committing the .top* files in sane
582 state. It will add the hooks to separate files within the hooks/
583 subdirectory and merely insert calls of them to the appropriate hooks
584 and make them executable (but make sure the original hooks code
585 is not called if the hook was not executable beforehand).
586
587 Another automagically installed piece is .git/info/attributes specifier
588 for an 'ours' merge strategy for the files .topmsg and .topdeps, and
589 the (intuitive) 'ours' merge strategy definition in .git/config.
590
591
592 REMOTE HANDLING
593 ---------------
594
595 There are three issues with accessing topic branches in remote repositories:
596
597         (i) Fetching/pushing accurate picture of the remote topic branch setup
598         (ii) Referring to remote topic branches from your local repository
599         (iii) Developing some of the remote topic branches locally
600
601 (ii) and (iii) are fairly interconnected problems, while (i) is largely
602 independent. The issue is to accurately reflect the current state of the
603 quickly changing topic branches set - this can be easily done
604 with the current facilities like 'git remote prune' and 'git push --mirror' -
605 and to properly upload also the bases of the topic branches.
606 For this, we need to modify the fetch/push refspecs to also include
607 the refs/top-bases/ ref namespace; we shall provide a special 'tg remote'
608 command to set up an existing remote for TopGit usage.
609
610 About (ii) and (iii), there are two somewhat contradicting design
611 considerations:
612
613         (a) Hacking on multiple independent TopGit remotes in a single
614         repository
615         (b) Having a self-contained topic system in local refs space
616
617 To us, (a) does not appear to be very convincing, while (b) is quite desirable
618 for 'git-log topic' etc. working, 'git push' automatically creating
619 self-contained topic system in the remote repository, and increased conceptual
620 simplicity.
621
622 Thus, we choose to instantiate all the topic branches of given remote locally;
623 this is performed by 'tg remote --populate'.
624 'tg update' will also check if a branch can be updated from its corresponding
625 remote branch. The logic is somewhat involved if we should DTRT.
626 First, we update the base, handling the remote branch as if it was the first
627 dependency; thus, conflict resolutions made in the remote branch will be
628 carried over to our local base automagically. Then, the base is merged into
629 remote branch and the result is merged to local branch - again, to carry over
630 remote conflict resolutions. In the future, this order might be adjustable
631 per-update in case local changes are diverging more than the remote ones.
632
633 All commands by default refer to the remote that 'tg remote --populate'
634 was called on the last time ('topgit.remote' configuration variable). You can
635 manually run any command with a different base remote by passing '-r REMOTE'
636 _before_ the subcommand name.
637
638
639 POINTERS
640 --------
641
642 The following references are useful to understand the development of topgit and
643 its subcommands.
644
645 tg depend:
646   http://lists-archives.org/git/688698-add-list-and-rm-sub-commands-to-tg-depend.html