4.3 Copying Changes Between Branches | Version Control with Subversion

Now you and Sally are working on parallel branches of the project: you're working on a private branch, and Sally is working on the trunk, or main line of development.

For projects that have a large number of contributors, it's common for most people to have working copies of the trunk. Whenever someone needs to make a long-running change that is likely to disrupt the trunk, a standard procedure is to create a private branch and commit changes there until all the work is complete.

So, the good news is that you and Sally aren't interfering with each other. The bad news is that it's very easy to drift too far apart. Remember that one of the problems with the crawl-in-a-hole strategy is that by the time you're finished with your branch, it may be near impossible to merge your changes back into the trunk without a huge number of conflicts.

Instead, you and Sally might continue to share changes as you work. It's up to you to decide which changes are worth sharing; Subversion gives you the ability to selectively copy changes between branches. And when you're completely finished with your branch, your entire set of branch changes can be copied back into the trunk.

4.3.1 Copying Specific Changes

In the previous section, we mentioned that both you and Sally made changes to integer.c on different branches. If you look at Sally's log message for revision 344, you can see that she fixed some spelling errors. No doubt, your copy of the same file still has the same spelling errors. It's likely that your future changes to this file will be affecting the same areas that have the spelling errors, so you're in for some potential conflicts when you merge your branch someday. It's better, then, to receive Sally's change now, before you start working too heavily in the same places.

It's time to use the svn merge command. This command, it turns out, is a very close cousin to the svn diff command (which you read about in Chapter 3). Both commands are able to compare any two objects in the repository and describe the differences. For example, you can ask svn diff to show you the exact change made by Sally in revision 344:

$ svn diff -r 343:344 http://svn.example.com/repos/calc/trunk Index: integer.c = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = --- integer.c        (revision 343) +++ integer.c        (revision 344) @@ -147,7 +147,7 @@      case 6:  sprintf(info->operating_system, "HPFS (OS/2 or NT)"); break;      case 7:  sprintf(info->operating_system, "Macintosh"); break;      case 8:  sprintf(info->operating_system, "Z-System"); break; -    case 9:  sprintf(info->operating_system, "CPM"); break; +    case 9:  sprintf(info->operating_system, "CP/M"); break;      case 10:  sprintf(info->operating_system, "TOPS-20"); break;      case 11:  sprintf(info->operating_system, "NTFS (Windows NT)"); break;      case 12:  sprintf(info->operating_system, "QDOS"); break; @@ -164,7 +164,7 @@      low = (unsigned short) read_byte(gzfile);  /* read LSB */      high = (unsigned short) read_byte(gzfile); /* read MSB */      high = high << 8;  /* interpret MSB correctly */ -    total = low + high; /* add them togethe for correct total */ +    total = low + high; /* add them together for correct total */        info->extra_header = (unsigned char *) my_malloc(total);      fread(info->extra_header, total, 1, gzfile); @@ -241,7 +241,7 @@       Store the offset with ftell( ) ! */      if ((info->data_offset = ftell(gzfile))= = -1) { -    printf("error: ftell( ) retturned -1.\n"); +    printf("error: ftell( ) returned -1.\n");      exit(1);    }   @@ -249,7 +249,7 @@    printf("I believe start of compressed data is %u\n", info->data_offset);    #endif     -  /* Set postion eight bytes from the end of the file. */ +  /* Set position eight bytes from the end of the file. */      if (fseek(gzfile, -8, SEEK_END)) {      printf("error: fseek( ) returned non-zero\n");

The svn merge is almost exactly the same. Instead of printing the differences to your terminal, however, it applies them directly to your working copy as local modifications:

$ svn merge -r 343:344 http://svn.example.com/repos/calc/trunk U  integer.c $ svn status M  integer.c

The output of svn merge shows that your copy of integer.c was patched. It now contains Sally's change the change has been copied from the trunk to your working copy of your private branch, and now exists as a local modification. At this point, it's up to you to review the local modification and make sure it works correctly.

In another scenario, it's possible that things may not have gone so well, and that integer.c may have entered a conflicted state. You might need to resolve the conflict using standard procedures (see Chapter 3), or if you decide that the merge was a bad idea altogether, simply give up and svn revert the local change.

But assuming that you've reviewed the merged change, you can svn commit the change as usual. At that point, the change has been merged into your repository branch. In version control terminology, this act of copying changes between branches is commonly called porting changes.

When you commit the local modification, make sure your log message mentions that you're porting a specific change from one branch to another. For example:

$ svn commit -m "integer.c: ported r344 (spelling fixes) from trunk." Sending        integer.c Transmitting file data . Committed revision 360.

As you'll see in the next sections, this is a very important best practice to follow.

Why Not Use Patches Instead?

A question may be on your mind, especially if you're a Unix user: why bother to use svn merge at all? Why not simply use the operating system's patch command to accomplish the same job? For example:

$ svn diff -r 343:344 http://svn.example.com/repos/calc/trunk > patchfile $ patch -p0  < patchfile Patching file integer.c using Plan A... Hunk #1 succeeded at 147. Hunk #2 succeeded at 164. Hunk #3 succeeded at 241. Hunk #4 succeeded at 249. done

In this particular case, yes, there really is no difference. But svn merge has special abilities that surpass the patch program. The file format used by patch is quite limited; it's only able to tweak file contents. There's no way to represent changes to trees, such as the addition, removal, or renaming of files and directories. If Sally's change had, for instance, added a new directory, the output of svn diff wouldn't have mentioned it at all. svn diff only outputs the limited patch-format, so there are some ideas it simply can't express.^[1] The svn merge command, however, can express tree changes by directly applying them to your working copy.

^[1] In the future, the Subversion project plans to use (or invent) an expanded patch format that describes tree-changes.

A word of warning: while svn diff and svn merge are very similar in concept, they do have different syntax in many cases. Be sure to read about them in Chapter 8 for details, or ask svn help. For example, svn merge requires a working-copy path as a target, i.e., a place where it should apply the tree-changes. If the target isn't specified, it assumes you are trying to perform one of the following common operations:

You want to merge directory changes into your current working directory.
You want to merge the changes in a specific file into a file by the same name that exists in your current working directory.

If you are merging a directory and haven't specified a target path, svn merge assumes the first case and tries to apply the changes into your current directory. If you are merging a file, and that file (or a file by the same name) exists in your current working directory, svn merge assumes the second case and tries to apply the changes to a local file with the same name.

If you want changes applied somewhere else, you need to say so explicitly. For example, if you're sitting in the parent directory of your working copy, you have to specify the target directory to receive the changes:

$ svn merge -r 343:344 http://svn.example.com/repos/calc/trunk my-calc-branch U   my-calc-branch/integer.c

4.3.2 Best Practices for Merging

Merging changes sounds simple enough, but in practice it can become a headache. The problem is that if you repeatedly merge changes from one branch to another, you might accidentally merge the same change twice. When this happens, sometimes things will work fine. When patching a file, Subversion typically notices if the file already has the change, and does nothing. But if the already existing change has been modified in any way, you'll get a conflict.

Ideally, your version control system should prevent the double application of changes to a branch. It should automatically remember which changes a branch has already received, and be able to list them for you. It should use this information to help automate merges as much as possible.

Unfortunately, Subversion is not such a system. Like CVS, Subversion 1.0 does not yet record any information about merge operations. When you commit local modifications, the repository has no idea whether those changes came from running svn merge, or from just hand-editing the files.

4.3.2.1 Tracking merges manually

What does this mean to you, the user? It means that until the day Subversion grows this feature, you'll have to track merge information yourself. The best place to do this is in the commit log-message. As demonstrated in the earlier example, it's recommended that your log-message mention a specific revision number (or range of revisions) that are being merged into your branch. Later on, you can run svn log to review which changes your branch already contains. This lets you carefully construct a subsequent svn merge command that won't be redundant with previously ported changes.

In the next section, we show some examples of this merge tracking technique in action.

4.3.2.2 Previewing merges

Because merging only results in local modifications, it's not usually a high-risk operation. If you get the merge wrong the first time, simply svn revert the changes and try again.

It's possible, however, that your working copy might already have local modifications. The changes applied by a merge will be mixed with your preexisting ones, and running svn revert is no longer an option. The two sets of changes may be impossible to separate.

In cases such as this, people take comfort in being able to predict or examine merges before they happen. One simple way to do that is to run svn diff with the same arguments you plan to pass to svn merge, as we already showed in our first example of merging. Another method of previewing is to pass the --dry-run option to the merge command:

$ svn merge --dry-run -r 343:344 http://svn.example.com/repos/calc/trunk U  integer.c $ svn status #  nothing printed, working copy is still unchanged.

The --dry-run option doesn't actually apply any local changes to the working copy. It only shows status codes that would be printed in a real merge. It's useful for getting a high-level preview of the potential merge, for those times when running svn diff gives too much detail.

4.3.2.3 Noticing or Ignoring Ancestry

When conversing with a Subversion developer, you might very likely hear reference to the term ancestry. This word is used to describe the relationship between two objects in a repository: if they're related to each other, than one object is said to be an ancestor of the other.

For example, suppose you commit revision 100, which includes a change to a file foo.c. Then foo.c@99 is an ancestor of foo.c@100. On the other hand, suppose you commit the deletion of foo.c in revision 101, and then add a new file by the same name in revision 102. In this case, foo.c@99 and foo.c@102 may appear to be related (they have the same path), but in fact are completely different objects in the repository. They share no history or ancestry.

The reason for bringing this up is to point out an important difference between svn diff and svn merge. The former command ignores ancestry, while the latter command is quite sensitive to it. For example, if you asked svn diff to compare revisions 99 and 102 of foo.c, you would see line-based diffs; the diff command is blindly comparing two paths. But if you asked svn merge to compare the same two objects, it would notice that they're unrelated and first attempt to delete the old file, then add the new file; you would see a D foo.c followed by a A foo.c.

Most merges involve comparing trees that are ancestrally related to one another, and therefore svn merge defaults to this behavior. Occasionally, however, you may want the merge command to compare two unrelated trees. For example, you may have imported two source-code trees representing different vendor releases of a software project (see Section 7.4 in Chapter 7). If you asked svn merge to compare the two trees, you'd see the entire first tree being deleted, followed by an add of the entire second tree!

In these situations, you'll want svn merge to do a path-based comparison only, ignoring any relations between files and directories. Add the --ignore-ancestry option to your merge command, and it will behave just like svn diff. (And conversely, the --notice-ancestry option will cause svn diff to behave like the merge command.)