When you check out a branch or commit with git, two things happen: git changes the files in the repository folder, and changes the file that tells it what is currently checked out. In git terms, it changes what HEAD points to. In practical terms, it updates the .git/HEAD text file to contain a different reference.
But these two operations can be done separate from one another, so that while the files correspond to one commit, git thinks that the HEAD commit is another one.
This of course puts your git repository in an unstable, even unnatural state. But there are useful reasons for doing this, and one of these comes up in the operation of dorgflow, my tool for working with git and drupal.org patches.
Dorgflow creates a local branch for a drupal.org issue, and creates a commit for each patch, so you end up with a nice sequential representation of the work that’s been done so far.
But every patch that’s uploaded to an issue is a patch against the master branch, so we can’t just apply the patches one by one and make commits: the first patch will apply, and all the subsequent ones will fail.
What we need is for the files be in the same state as the master branch, so that the patch applies, but when we make a commit, it needs to be a new commit on the feature branch:
* [Feature branch] Patch 1 <- Make patch 2 commit on top of this commit.
* [master branch] Latest master commit. <- Apply patch 2 to these files.
In git terms, we want the current files (the working tree, as git calls it) to be on the master branch, while git's HEAD is on the feature branch.
For my first attempt at getting this to work, I did the following:
- Put git on the feature branch.
- Check out the master branch's files, with
git checkout master -- .
When you use
git checkout command with a file or files specified, it doesn't move HEAD, but instead changes just those files to the given commit or branch. If you give '.' as the file to check out, then it does that for all of the repository's files. In effect, you get the files to look like the given commit, in our case the master branch.
This is what we want, but it has one crucial flaw. Suppose patch 1 added a new file, foo.php. When we check out master's files, foo.php is not changed, because it's not on master. There's nothing on master to overwrite it. The 'git checkout master -- .' doesn't actually say 'make all the files look like master', it says 'check out all the files from master'. foo.php isn't on master, and so it's simply left alone.
Suppose now that patch 2 also adds the foo.php file, which it most likely will, since in most cases, a newer patch incorporates all the work of the previous one.
Applying patch 2 to the files in their current state will fail, because patch 2 tries to create the file foo.php, but it's already there.
So this approach is no good. I was stuck with this problem with dorgflow for months, until I had a brainwave: instead of staying on the feature branch and changing the files to look like master, why not check out the master branch, but tell git that the HEAD is the feature branch?
That solves the problem of the foo.php file: when you check out master, the foo.php that's at the patch 1 commit vanishes, because it doesn't exist on master. So applying patch 2 will be fine.
The only remaining question was how to you tell git it's on a different branch without doing a checkout of files? Turns out this is a simple plumbing command:
git symbolic-ref HEAD refs/heads/BRANCH. This is just telling git to change the reference that HEAD points to, and that's how git stores the fact that a particular branch is the current one.
This was a simple change to make in dorgflow (it was actually more work to update the tests so the mocks had the correct method call expectations!).
This means that dorgflow accordingly now handles applying a sequence of issue patches that add files now works in the latest release.