Collectives on Stack Overflow. Learn more. How do I branch a modified working copy with SVN? Ask Question. Asked 9 years, 1 month ago. Active 4 years ago. Viewed 14k times. So: I would like to make a new branch, based on my working copy, without having to check in my working copy it IS up to date with the latest HEAD revision though Once I have forked my working copy, I would like to basically remove all changes that are in the branch, and just set it to match the current HEAD revision in trunk.
Improve this question. Tom Auger Tom Auger A similar question here — Ashley. Add a comment. Active Oldest Votes. Either check out a clean copy or do svn update on an existing check out to make sure all new files have been added and all existing files are up to date.
Using --stop-on-copy ends the log where the branch began. If you have already synced this branch with the trunk, look for the most recent entry describing the merge.
For example r frewen Tue, 29 Jun 8 lines Merged trunk changes into the side-project branch. Smoke and unit tests all pass. This version of the branch will now be merged into the trunk. For the rest of the example, we'll use r Moving changes from the trunk into the branch is much the same as merging in the other direction.
When retrieving svn commits into Git as part of fetch , rebase , or dcommit operations , look for the first From: line or Signed-off-by trailer in the log message and use that as the author string. If you use this, then --use-log-author will retrieve a valid author string for all commits. This allows the user to override the default refname to fetch from when tracking a single URL. The log and dcommit commands no longer require this switch as an argument.
Default: "svn". This option is only relevant if we are tracking branches using one of the repository layout options --trunk, --tags, --branches, --stdlayout. For each tracked branch, try to find out where its revision was copied from, and set a suitable parent in the first Git commit for the branch.
If this feature is disabled, the branches created by git svn will all be linear and not share any history, meaning that there will be no information on where branches were branched off or merged. This feature is enabled by default, use --no-follow-parent to disable it. This option can only be used for one-shot imports as git svn will not be able to fetch again without metadata. The git svn log command will not work on repositories using this, either. Using this conflicts with the useSvmProps option for hopefully obvious reasons.
This option is NOT recommended as it makes it difficult to track down old references to SVN revision numbers in existing documentation, bug reports, and archives. The property contains a repository UUID and a revision.
We want to make it look like we are mirroring the original URL, so introduce a helper function that returns the original identity URL and UUID, and use it when generating metadata in commit messages. Similar to the useSvmProps option; this is for users of the svnsync 1 command distributed with SVN 1. This allows users to create repositories from alternate URLs. It is assumed that both keys point to the same repository.
Unlike commiturl , pushurl is a base path. If either commiturl or pushurl could be used, commiturl takes precedence. This disables potentially expensive checks to workaround broken symlinks checked into SVN by broken clients.
Set this option to "false" if you track a SVN repository with many empty blobs that are not symlinks. This option may be changed while git svn is running and take effect on the next revision fetched.
If unset, git svn assumes this option to be "true". This instructs git svn to recode pathnames to a given encoding. It can be used by windows users and by those who work in non-utf8 locales to avoid corrupted file names with non-ASCII characters.
Normally, the "git svn clone" and "git svn rebase" commands attempt to recreate empty directories that are in the Subversion repository. If this option is set to "false", then empty directories will only be created if the "git svn mkdirs" command is run explicitly. Since the noMetadata, rewriteRoot, rewriteUUID, useSvnsyncProps and useSvmProps options all affect the metadata generated and used by git svn ; they must be set in the configuration file before any history is imported and these settings should never be changed once they are set.
Additionally, only one of these options can be used per svn-remote section because they affect the git-svn-id: metadata line, except for rewriteRoot and rewriteUUID which can be used together. Tracking and contributing to the trunk of a Subversion-managed project ignoring tags and branches :. Tracking and contributing to an entire Subversion-managed project complete with a trunk, tags and branches :.
The initial git svn clone can be quite time-consuming especially for large Subversion repositories. If multiple people or one person with multiple machines want to use git svn to interact with the same Subversion repository, you can do the initial git svn clone to a repository on a server and have each person clone that repository with git clone :.
Prefer to use git svn rebase or git rebase , rather than git pull or git merge to synchronize unintegrated commits with a git svn branch. Doing so will keep the history of unintegrated commits linear with respect to the upstream SVN repository and allow the use of the preferred git svn dcommit subcommand to push unintegrated commits back into SVN. Originally, git svn recommended that developers pulled or merged from the git svn branch.
This was because the author favored git svn set-tree B to commit a single head rather than the git svn set-tree A.. B notation to commit multiple commits. Use of git pull or git merge with git svn set-tree A.. B will cause non-linear history to be flattened when committing into SVN and this can lead to merge commits unexpectedly reversing previous commits in SVN.
While git svn can track copy history including branches and tags for repositories adopting a standard layout, it cannot yet represent merge history that happened inside git back upstream to SVN users.
If git svn is configured to fetch branches and --follow-branches is in effect , it sometimes creates multiple Git branches for one SVN branch, where the additional branches have names of the form branchname nnn with nnn an SVN revision number. These additional branches are created if git svn cannot find a parent commit for the first commit in an SVN branch, to connect the branch to the history of the other branches.
Normally, the first commit in an SVN branch consists of a copy operation. It will then try to find the Git commit that corresponds to this SVN revision, and use that as the parent of the branch. However, it is possible that there is no suitable Git commit to serve as parent.
This will happen, among other reasons, if the SVN branch is a copy of a revision that was not fetched by git svn e. In these cases, git svn will still create a Git branch, but instead of using an existing Git commit as the parent of the branch, it will read the SVN history of the directory the branch was copied from and create appropriate Git commits. This branch will point to the newly created parent commit of the branch.
If in SVN the branch was deleted and later recreated from a different version, there will be multiple such branches with an. It will also create new Git commits for r. When this happens, it's easy to recursively revert all the changes created by the merge svn revert --recursive , delete any unversioned files or directories left behind after the revert, and re-run svn merge with different arguments.
Also notice that the previous example shows a conflict happening on glorb. We already stated that the working copy has no local edits: how can a conflict possibly happen? Again, because the user can use svn merge to define and apply any old delta to the working copy, that delta may contain textual changes that don't cleanly apply to a working file, even if the file has no local modifications. Another small difference between svn update and svn merge are the names of the full-text files created when a conflict happens.
When svn merge produces a conflict, though, it creates three files named filename. In any case, these differing names will help you distinguish between conflicts that happened as a result of an update versus ones that happened as a result of a merge. 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, then one object is said to be an ancestor of the other. For example, suppose you commit revision , which includes a change to a file foo. Then foo.
On the other hand, suppose you commit the deletion of foo. In this case, foo. 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 of foo. 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; the output would indicate a deletion followed by an add:.
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.
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.
A common desire is to refactor source code, especially in Java-based software projects. Files and directories are shuffled around and renamed, often causing great disruption to everyone working on the project.
Sounds like a perfect case to use a branch, doesn't it? Just create a branch, shuffle things around, then merge the branch back to the trunk, right? Alas, this scenario doesn't work so well right now, and is considered one of Subversion's current weak spots. The problem is that Subversion's update command isn't as robust as it should be, particularly when dealing with copy and move operations.
When you use svn copy to duplicate a file, the repository remembers where the new file came from, but it fails to transmit that information to the client which is running svn update or svn merge. This can lead to problems, especially because the same thing happens with renamed files. For example, suppose that while working on your private branch, you rename integer.
Effectively you've created a new file in your branch that is a copy of the original file, and deleted the original file.
Meanwhile, back on trunk , Sally has committed some improvements to integer. Now you decide to merge your branch to the trunk:. This doesn't look so bad at first glance, but it's also probably not what you or Sally expected. The merge operation has deleted the latest version of integer. This isn't true data-loss; Sally's changes are still in the repository's history, but it may not be immediately obvious that this has happened. The moral of this story is that until Subversion improves, be very careful about merging copies and renames from one branch to another.
0コメント