Fetching latest commit…
Cannot retrieve the latest commit at this time.
|Failed to load latest commit information.|
TopGit - A different patch queue manager DESCRIPTION ----------- TopGit aims to make handling of large amounts of interdependent topic branches easier. In fact, it is designed especially for the case where you maintain a queue of third-party patches on top of another (perhaps Git-controlled) project and want to easily organize, maintain and submit them - TopGit achieves that by keeping a separate topic branch for each patch and providing some tools to maintain the branches. INSTALLATION ------------ See the file INSTALL. RATIONALE --------- Why not use something like StGIT or Guilt or 'rebase -i' for maintaining your patch queue? The advantage of these tools is their simplicity; they work with patch _series_ and defer to the reflog facility for version control of patches (reordering of patches is not version-controlled at all). But there are several disadvantages - for one, these tools (especially StGIT) do not actually fit well with plain Git at all: it is basically impossible to take advantage of the index effectively when using StGIT. But more importantly, these tools horribly fail in the face of a distributed environment. TopGit has been designed around three main tenets: (i) TopGit is as thin a layer on top of Git as possible. You still maintain your index and commit using Git; TopGit will only automate a few indispensable tasks. (ii) TopGit is anxious about _keeping_ your history. It will never rewrite your history, and all metadata is also tracked by Git, smoothly and non-obnoxiously. It is good to have a _single_ point when the history is cleaned up, and that is at the point of inclusion in the upstream project; locally, you can see how your patch has evolved and easily return to older versions. (iii) TopGit is specifically designed to work in a distributed environment. You can have several instances of TopGit-aware repositories and smoothly keep them all up-to-date and transfer your changes between them. As mentioned above, the main intended use-case for TopGit is tracking third-party patches, where each patch is effectively a single topic branch. In order to flexibly accommodate even complex scenarios when you track many patches where many are independent but some depend on others, TopGit ignores the ancient Quilt heritage of patch series and instead allows the patches to freely form graphs (DAGs just like Git history itself, only "one level higher"). For now, you have to manually specify which patches the current one depends on, but TopGit might help you with that in the future in a darcs-like fashion. A glossary plug: The union (i.e. merge) of patch dependencies is called a _base_ of the patch (topic branch). Of course, TopGit is perhaps not the right tool for you: (i) TopGit is not complicated, but StGIT et al. are somewhat simpler, conceptually. If you just want to make a linear purely-local patch queue, deferring to StGIT instead might make more sense. (ii) When using TopGit, your history can get a little hairy over time, especially with all the merges rippling through. ;-) SYNOPSIS -------- ## Create and evolve a topic branch $ tg create t/gitweb/pathinfo-action tg: Automatically marking dependency on master tg: Creating t/gitweb/pathinfo-action base from master... $ ..hack.. $ git commit $ ..fix a mistake.. $ git commit ## Create another topic branch on top of the former one $ tg create t/gitweb/nifty-links tg: Automatically marking dependency on t/gitweb/pathinfo-action tg: Creating t/gitweb/nifty-links base from t/gitweb/pathinfo-action... $ ..hack.. $ git commit ## Create another topic branch on top of master and submit ## the resulting patch upstream $ tg create t/revlist/author-fixed master tg: Creating t/revlist/author-fixed base from master... $ ..hack.. $ git commit $ tg patch -m tg: Sent t/revlist/author-fixed From: firstname.lastname@example.org To: email@example.com Cc: firstname.lastname@example.org Subject: [PATCH] Fix broken revlist --author when --fixed-string ## Create another topic branch depending on two others non-trivially $ tg create t/whatever t/revlist/author-fixed t/gitweb/nifty-links tg: Creating t/whatever base from t/revlist/author-fixed... tg: Merging t/whatever base with t/gitweb/nifty-links... Merge failed! tg: Please commit merge resolution and call: tg create tg: It is also safe to abort this operation using `git reset --hard` tg: but please remember you are on the base branch now; tg: you will want to switch to a different branch. $ ..resolve.. $ git commit $ tg create tg: Resuming t/whatever setup... $ ..hack.. $ git commit ## Update a single topic branch and propagate the changes to ## a different one $ git checkout t/gitweb/nifty-links $ ..hack.. $ git commit $ git checkout t/whatever $ tg info Topic Branch: t/whatever (1 commit) Subject: [PATCH] Whatever patch Base: 3f47ebc1 Depends: t/revlist/author-fixed t/gitweb/nifty-links Needs update from: t/gitweb/nifty-links (1 commit) $ tg update tg: Updating base with t/gitweb/nifty-links changes... Merge failed! tg: Please commit merge resolution and call `tg update` again. tg: It is also safe to abort this operation using `git reset --hard`, tg: but please remember you are on the base branch now; tg: you will want to switch to a different branch. $ ..resolve.. $ git commit $ tg update tg: Updating t/whatever against new base... Merge failed! tg: Please resolve the merge and commit. No need to do anything else. tg: You can abort this operation using `git reset --hard` now tg: and retry this merge later using `tg update`. $ ..resolve.. $ git commit ## Update a single topic branch and propagate the changes ## further through the dependency chain $ git checkout t/gitweb/pathinfo-action $ ..hack.. $ git commit $ git checkout t/whatever $ tg info Topic Branch: t/whatever (1/2 commits) Subject: [PATCH] Whatever patch Base: 0ab2c9b3 Depends: t/revlist/author-fixed t/gitweb/nifty-links Needs update from: t/gitweb/pathinfo-action (<= t/gitweb/nifty-links) (1 commit) $ tg update tg: Recursing to t/gitweb/nifty-links... [t/gitweb/nifty-links] tg: Updating base with t/gitweb/pathinfo-action changes... Merge failed! [t/gitweb/nifty-links] tg: Please commit merge resolution and call `tg update` again. [t/gitweb/nifty-links] tg: It is also safe to abort this operation using `git reset --hard`, [t/gitweb/nifty-links] tg: but please remember you are on the base branch now; [t/gitweb/nifty-links] tg: you will want to switch to a different branch. [t/gitweb/nifty-links] tg: You are in a subshell. If you abort the merge, [t/gitweb/nifty-links] tg: use `exit` to abort the recursive update altogether. [t/gitweb/nifty-links] $ ..resolve.. [t/gitweb/nifty-links] $ git commit [t/gitweb/nifty-links] $ tg update [t/gitweb/nifty-links] tg: Updating t/gitweb/nifty-links against new base... Merge failed! [t/gitweb/nifty-links] tg: Please resolve the merge and commit. [t/gitweb/nifty-links] tg: You can abort this operation using `git reset --hard`. [t/gitweb/nifty-links] tg: You are in a subshell. After you either commit or abort [t/gitweb/nifty-links] tg: your merge, use `exit` to proceed with the recursive update. [t/gitweb/nifty-links] $ ..resolve.. [t/gitweb/nifty-links] $ git commit [t/gitweb/nifty-links] $ exit tg: Updating base with t/gitweb/nifty-links changes... tg: Updating t/whatever against new base... ## Clone a TopGit-controlled repository $ git clone URL repo $ cd repo $ tg remote --populate origin ... $ git fetch $ tg update ## Add a TopGit remote to a repository and push to it $ git remote add foo URL $ tg remote foo $ tg push -r foo ## Update from a non-default TopGit remote $ git fetch foo $ tg -r foo summary $ tg -r foo update USAGE ----- The 'tg' tool has several subcommands: tg help ~~~~~~~ Our sophisticated integrated help facility. Mostly duplicates what is below, except for adding summary Usage lines. # to list commands: $ tg help # to get help for a particular command: $ tg help <command> tg create ~~~~~~~~~ Create a new TopGit-controlled topic branch of the given name (required argument) and switch to it. If no dependencies are specified (by extra arguments passed after the first one), the current branch is assumed to be the only dependency. After `tg create`, you should insert the patch description into the '.topmsg' file, which will already contain some prefilled bits. You can set the 'topgit.to', 'topgit.cc' and 'topgit.bcc' git configuration variables (see `man git-config`) in order to have `tg create` add these headers with the given default values to '.topmsg'. The main task of `tg create` is to set up the topic branch base from the dependencies. This may fail due to merge conflicts. In that case, after you commit the conflict resolution, you should call `tg create` again (without any arguments); it will detect that you are on a topic branch base ref and resume the topic branch creation operation. In an alternative use case, if '-r BRANCH' is given instead of a dependency list, the topic branch is created based on the given remote branch. tg delete ~~~~~~~~~ Remove a TopGit-controlled topic branch of the given name (required argument). Normally, this command will remove only an empty branch (base == head) without dependendents; use '-f' to remove a non-empty branch or a branch that is depended upon by another branch. The '-f' option is also useful to force removal of a branch's base, if you used `git branch -D B` to remove branch B, and then certain TopGit commands complain, because the base of branch B is still there. IMPORTANT: Currently, this command will _NOT_ remove the branch from the dependency list in other branches. You need to take care of this _manually_. This is even more complicated in combination with '-f' - in that case, you need to manually unmerge the removed branch's changes from the branches depending on it. TODO: '-a' to delete all empty branches, depfix, revert tg depend ~~~~~~~~~ Change the dependencies of a TopGit-controlled topic branch. This should have several subcommands, but only `add` is supported right now. The `add` subcommand takes an argument naming a topic branch to be added, adds it to '.topdeps', performs a commit and then updates your topic branch accordingly. If you want to do other things related to the dependency addition, like adjusting '.topmsg', prepare them in the index before calling `tg depend add`. TODO: Subcommand for removing dependencies, obviously tg files ~~~~~~~~ List files changed by the current or specified topic branch. Options: -i list files based on index instead of branch -w list files based on working tree instead of branch tg info ~~~~~~~ Show summary information about the current or specified topic branch. tg patch ~~~~~~~~ Generate a patch from the current or specified topic branch. This means that the diff between the topic branch base and head (latest commit) is shown, appended to the description found in the '.topmsg' file. The patch is simply dumped to stdout. In the future, `tg patch` will be able to automatically send the patches by mail or save them to files. (TODO) Options: -i base patch generation on index instead of branch -w base patch generation on working tree instead of branch tg mail ~~~~~~~ Send a patch from the current or specified topic branch as email(s). Takes the patch given on the command line and emails it out. Destination addresses such as To, Cc and Bcc are taken from the patch header. Since it actually boils down to `git send-email`, please refer to the documentation for that for details on how to setup email for git. You can pass arbitrary options to this command through the '-s' parameter, but you must double-quote everything. The '-r' parameter with a msgid can be used to generate in-reply-to and reference headers to an earlier mail. WARNING: be careful when using this command. It easily sends out several mails. You might want to run git config sendemail.confirm always to let `git send-email` ask for confirmation before sending any mail. Options: -i base patch generation on index instead of branch -w base patch generation on working tree instead of branch TODO: 'tg mail patchfile' to mail an already exported patch TODO: mailing patch series TODO: specifying additional options and addresses on command line tg remote ~~~~~~~~~ Register the given remote as TopGit-controlled. This will create the namespace for the remote branch bases and teach `git fetch` to operate on them. However, from TopGit 0.8 onwards you need to use `tg push`, or `git push --mirror`, for pushing TopGit-controlled branches. `tg remote` takes an optional remote name argument, and an optional '--populate' switch. Use '--populate' for your origin-style remotes: it will seed the local topic branch system based on the remote topic branches. '--populate' will also make `tg remote` automatically fetch the remote, and `tg update` look at branches of this remote for updates by default. tg summary ~~~~~~~~~~ Show overview of all TopGit-tracked topic branches and their up-to-date status ('>' marks the current topic branch, '0' indicates that it introduces no changes of its own, 'l'/'r' indicates respectively whether it is local-only or has a remote mate, 'L'/'R' indicates respectively if it is ahead or out-of-date with respect to its remote mate, 'D' indicates that it is out-of-date with respect to its dependencies, '!' indicates that it has missing dependencies [even if they are recursive ones], and 'B' indicates that it is out-of-date with respect to its base). This can take a long time to accurately determine all the relevant information about each branch; you can pass '-t' to get just a terse list of topic branch names quickly. Alternately, you can pass '--graphviz' to get a dot-suitable output to draw a dependency graph between the topic branches. You can also use the '--sort' option to sort the branches using a topological sort. This is especially useful if each TopGit-tracked topic branch depends on a single parent branch, since it will then print the branches in the dependency order. In more complex scenarios, a text graph view would be much more useful, but that has not yet been implemented. The --deps option outputs dependency information between branches in a machine-readable format. Feed this to `tsort` to get the output from --sort. Options: -i Use TopGit metadata from the index instead of the branch -w Use TopGit metadata from the working tree instead of the branch TODO: Speed up by an order of magnitude TODO: Text graph view tg export ~~~~~~~~~ Export a tidied-up history of the current topic branch and its dependencies, suitable for feeding upstream. Each topic branch corresponds to a single commit or patch in the cleaned up history (corresponding basically exactly to `tg patch` output for the topic branch). The command has three possible outputs now - either a Git branch with the collapsed history, a Git branch with a linearized history, or a quilt series in new directory. In the case where you are producing collapsed history in a new branch, you can use this collapsed structure either for providing a pull source for upstream, or for further linearization e.g. for creation of a quilt series using git log: git log --pretty=email -p --topo-order origin..exported To better understand the function of `tg export`, consider this dependency structure: origin/master - t/foo/blue - t/foo/red - master `- t/bar/good <,----------' `- t/baz ------------' (where each of the branches may have a hefty history). Then master$ tg export for-linus will create this commit structure on the branch 'for-linus': origin/master - t/foo/blue -. merge - t/foo/red -.. merge - master `- t/bar/good <,-------------------'/ `- t/baz ---------------------' In this mode, `tg export` works on the current topic branch, and can be called either without an option (in that case, '--collapse' is assumed), or with the '--collapse' option, and with one mandatory argument: the name of the branch where the exported result will be stored. WARNING: The branch will be silently overwritten if it exists already! If you make a mistake, use `git reflog` to recover. When using the linearize mode: master$ tg export --linearize for-linus you get a linear history respecting the dependencies of your patches in a new branch 'for-linus'. The result should be more or less the same as using quilt mode and then reimporting it into a Git branch. (More or less because the topological order can usually be extended in more than one way into a total order, and the two methods may choose different ones.) The result might be more appropriate for merging upstream, as it contains fewer merges. Note that you might get conflicts during linearization because the patches are reordered to get a linear history. When using the quilt mode, master$ tg export --quilt for-linus would create the following directory 'for-linus': for-linus/t/foo/blue.diff for-linus/t/foo/red.diff for-linus/t/bar/good.diff for-linus/t/baz.diff for-linus/series: t/foo/blue.diff -p1 t/bar/good.diff -p1 t/foo/red.diff -p1 t/baz.diff -p1 With '--quilt', you can also pass the '-b' parameter followed by a comma-separated explicit list of branches to export, or the '--all' parameter (which can be shortened to '-a') to export them all. These options are currently only supported with '--quilt'. In '--quilt' mode the patches are named like the originating topgit branch. So usually they end up in subdirectories of the output directory. With the '--flatten' option the names are mangled so that they end up directly in the output dir (slashes are substituted by underscores). With the '--strip[=N]' option the first 'N' subdirectories (all if no 'N' is given) get stripped off. Names are always '--strip'ped before being '--flatten'ed. With the option '--numbered' (which implies '--flatten') the patch names get a number as prefix to allow getting the order without consulting the series file, which eases sending out the patches. TODO: Make stripping of non-essential headers configurable TODO: Make stripping of [PATCH] and other prefixes configurable TODO: --mbox option to export instead as an mbox file TODO: support --all option in other modes of operation TODO: For quilt exporting, export the linearized history created in a temporary branch---this would allow producing conflict-less series tg import ~~~~~~~~~ Import commits within the given revision range into TopGit, creating one topic branch per commit. The dependencies are set up to form a linear sequence starting on your current branch - or a branch specified by the '-d' parameter, if present. The branch names are auto-guessed from the commit messages and prefixed by 't/' by default; use '-p <prefix>' to specify an alternative prefix (even an empty one). Alternatively, you can use the '-s NAME' parameter to specify the name of the target branch; the command will then take one more argument describing a _single_ commit to import. tg update ~~~~~~~~~ Update the current, specified or all topic branches with respect to changes in the branches they depend on and remote branches. This is performed in two phases - first, changes within the dependencies are merged to the base, then the base is merged into the topic branch. The output will guide you on what to do next in case of conflicts. When '-a' is specifed, updates all topic branches matched by <pattern>s (see `git-for-all-refs(1)` for details), or all if no <pattern> is given. After the update, if a single topic branch was specified, it is left as the current one; if '-a' was specified, it returns to the branch which was current at the beginning. If your dependencies are not up-to-date, `tg update` will first recurse into them and update them. If a remote branch update brings in dependencies on branches that are not yet instantiated locally, you can either bring in all the new branches from the remote using `tg remote --populate`, or only pick out the missing ones using `tg create -r` (`tg summary` will point out branches with incomplete dependencies by showing an '!' next to them). TODO: tg update -a -c to autoremove (clean) up-to-date branches tg push ~~~~~~~ pushes one, several or all TopGit-controlled topic branches - the current branch, if you don't specify which - to a remote repository. By default, the remote gets all the dependencies (both TopGit-controlled and non-TopGit-controlled) and bases pushed to it too. tg base ~~~~~~~ Prints the base commit of the current topic branch. Silently exits with exit code 1 if you are not working on a TopGit branch. tg log ~~~~~~ Prints the git log of the named topgit branch - or the current branch, if you don't specify a name. NOTE: if you have merged changes from a different repository, this command might not list all interesting commits. tg prev ~~~~~~~ Outputs the direct dependencies for the current or named branch. Options: -i show dependencies based on index instead of branch -w show dependencies based on working tree instead of branch tg next ~~~~~~~ Outputs all branches which directly depend on the current or named branch. Options: -i show dependencies based on index instead of branch -w show dependencies based on working tree instead of branch TODO: tg rename IMPLEMENTATION -------------- TopGit stores all the topic branches in the regular 'refs/heads/' namespace (so we recommend distinguishing them with the 't/' prefix). Apart from that, TopGit also maintains a set of auxiliary refs in 'refs/top-*'. Currently, only refs/top-bases/ is used, containing the current _base_ of the given topic branch - this is basically a merge of all the branches the topic branch depends on; it is updated during `tg update` and then merged to the topic branch, and it is the base of a patch generated from the topic branch by `tg patch`. All the metadata is tracked within the source tree and history of the topic branch itself, in .top* files; these files are kept isolated within the topic branches during TopGit-controlled merges and are of course omitted during `tg patch`. The state of these files in base commits is undefined; look at them only in the topic branches themselves. Currently, two files are defined: '.topmsg': Contains the description of the topic branch in a mail-like format, plus the author information, whatever Cc headers you choose or the post-three-dashes message. When mailing out your patch, basically only a few extra mail headers are inserted and then the patch itself is appended. Thus, as your patches evolve, you can record nuances like whether the particular patch should have To-list / Cc-maintainer or vice-versa and similar nuances, if your project is into that. 'From' is prefilled from your current `GIT_AUTHOR_IDENT`; other headers can be prefilled from various optional 'topgit.*' git config options. '.topdeps': Contains the one-per-line list of branches this branch depends on, pre-seeded by `tg create`. A (continuously updated) merge of these branches will be the "base" of your topic branch. IMPORTANT: DO NOT EDIT '.topdeps' MANUALLY!!! If you do so, you need to know exactly what are you doing, since this file must stay in sync with the Git history information, otherwise very bad things will happen. TopGit also automagically installs a bunch of custom commit-related hooks that will verify whether you are committing the '.top*' files in a sane state. It will add the hooks to separate files within the 'hooks/' subdirectory, and merely insert calls to them to the appropriate hooks and make them executable (but will make sure the original hook's code is not called if the hook was not executable beforehand). Another automagically installed piece is a '.git/info/attributes' specifier for an 'ours' merge strategy for the files '.topmsg' and '.topdeps', and the (intuitive) 'ours' merge strategy definition in '.git/config'. REMOTE HANDLING --------------- There are two remaining issues with accessing topic branches in remote repositories: (i) Referring to remote topic branches from your local repository (ii) Developing some of the remote topic branches locally There are two somewhat contradictory design considerations here: (a) Hacking on multiple independent TopGit remotes in a single repository (b) Having a self-contained topic system in local refs space To us, (a) does not appear to be very convincing, while (b) is quite desirable for 'git-log topic' etc. working, and increased conceptual simplicity. Thus, we choose to instantiate all the topic branches of given remote locally; this is performed by `tg remote --populate`. `tg update` will also check if a branch can be updated from its corresponding remote branch. The logic needs to be somewhat involved if we are to "do the right thing". First, we update the base, handling the remote branch as if it was the first dependency; thus, conflict resolutions made in the remote branch will be carried over to our local base automagically. Then, the base is merged into the remote branch and the result is merged to the local branch - again, to carry over remote conflict resolutions. In the future, this order might be adjustable on a per-update basis, in case local changes happen to be diverging more than the remote ones. All commands by default refer to the remote that `tg remote --populate` was called on the last time (stored in the 'topgit.remote' git configuration variable). You can manually run any command with a different base remote by passing '-r REMOTE' _before_ the subcommand name. REFERENCES ---------- The following references are useful to understand the development of topgit and its subcommands. * tg depend: http://lists-archives.org/git/688698-add-list-and-rm-sub-commands-to-tg-depend.html THIRD-PARTY SOFTWARE -------------------- The following software understands TopGit branches: * http://magit.github.com/magit/[magit] - a git mode for emacs IMPORTANT: Magit requires its topgit mode to be enabled first, as described in its documentation, in the "Activating extensions" subsection. If this is not done, it will not push TopGit branches correctly, so it's important to enable it even if you plan to mostly use TopGit from the command line.