Documentation/cvs-migration.txt

   1 Git for CVS users
   2 =================
   3
   4 Ok, so you're a CVS user. That's ok, it's a treatable condition, and the
   5 first step to recovery is admitting you have a problem. The fact that
   6 you are reading this file means that you may be well on that path
   7 already.
   8
   9 The thing about CVS is that it absolutely sucks as a source control
  10 manager, and you'll thus be happy with almost anything else. Git,
  11 however, may be a bit _too_ different (read: "good") for your taste, and
  12 does a lot of things differently.
  13
  14 One particular suckage of CVS is very hard to work around: CVS is
  15 basically a tool for tracking _file_ history, while git is a tool for
  16 tracking _project_ history.  This sometimes causes problems if you are
  17 used to doign very strange things in CVS, in particular if you're doing
  18 things like making branches of just a subset of the project.  Git can't
  19 track that, since git never tracks things on the level of an individual
  20 file, only on the whole project level.
  21
  22 The good news is that most people don't do that, and in fact most sane
  23 people think it's a bug in CVS that makes it tag (and check in changes)
  24 one file at a time.  So most projects you'll ever see will use CVS
  25 _as_if_ it was sane.  In which case you'll find it very easy indeed to
  26 move over to Git.
  27
  28 First off: this is not a git tutorial. See Documentation/tutorial.txt
  29 for how git actually works. This is more of a random collection of
  30 gotcha's and notes on converting from CVS to git.
  31
  32 Second: CVS has the notion of a "repository" as opposed to the thing
  33 that you're actually working in (your working directory, or your
  34 "checked out tree").  Git does not have that notion at all, and all git
  35 working directories _are_ the repositories.  However, you can easily
  36 emulate the CVS model by having one special "global repository", which
  37 people can synchronize with.  See details later, but in the meantime
  38 just keep in mind that with git, every checked out working tree will be
  39 a full revision control of its own.
  40
  41
  42 Importing a CVS archive
  43 -----------------------
  44
  45 Ok, you have an old project, and you want to at least give git a chance
  46 to see how it performs. The first thing you want to do (after you've
  47 gone through the git tutorial, and generally familiarized yourself with
  48 how to commit stuff etc in git) is to create a git'ified version of your
  49 CVS archive.
  50
  51 Happily, that's very easy indeed. Git will do it for you, although git
  52 will need the help of a program called "cvsps":
  53
  54         http://www.cobite.com/cvsps/
  55
  56 which is not actually related to git at all, but which makes CVS usage
  57 look almost sane (ie you almost certainly want to have it even if you
  58 decide to stay with CVS). However, git will want at _least_ version 2.1
  59 of cvsps (available at the address above), and in fact will currently
  60 refuse to work with anything else.
  61
  62 Once you've gotten (and installed) cvsps, you may or may not want to get
  63 any more familiar with it, but make sure it is in your path. After that,
  64 the magic command line is
  65
  66         git cvsimport <cvsroot> <module>
  67
  68 which will do exactly what you'd think it does: it will create a git
  69 archive of the named CVS module. The new archive will be created in a
  70 subdirectory named <module>.
  71
  72 It can take some time to actually do the conversion for a large archive,
  73 and the conversion script can be reasonably chatty, but on some not very
  74 scientific tests it averaged about eight revisions per second, so a
  75 medium-sized project should not take more than a couple of minutes.
  76
  77
  78 Emulating CVS behaviour
  79 -----------------------
  80
  81
  82 FIXME! Talk about setting up several repositories, and pulling and
  83 pushing between them. Talk about merging, and branches. Some of this
  84 needs to be in the tutorial too.
  85
  86
  87
  88 CVS annotate
  89 ------------
  90
  91 The core GIT itself does not have a "cvs annotate" equivalent.
  92 It has something that you may want to use when you would use
  93 "cvs annotate".
  94
  95 Let's step back a bit and think about the reason why you would
  96 want to do "cvs annotate a-file.c" to begin with.
  97
  98 You would use "cvs annotate" on a file when you have trouble
  99 with a function (or even a single "if" statement in a function)
 100 that happens to be defined in the file, which does not do what
 101 you want it to do.  And you would want to find out why it was
 102 written that way, because you are about to modify it to suit
 103 your needs, and at the same time you do not want to break its
 104 current callers.  For that, you are trying to find out why the
 105 original author did things that way in the original context.
 106
 107 Many times, it may be enough to see the commit log messages of
 108 commits that touch the file in question, possibly along with the
 109 patches themselves, like this:
 110
 111         $ git-whatchanged -p a-file.c
 112
 113 This will show log messages and patches for each commit that
 114 touches a-file.
 115
 116 This, however, may not be very useful when this file has many
 117 modifications that are not related to the piece of code you are
 118 interested in.  You would see many log messages and patches that
 119 do not have anything to do with the piece of code you are
 120 interested in.  As an example, assuming that you have this piece
 121 code that you are interested in in the HEAD version:
 122
 123         if (frotz) {
 124                 nitfol();
 125         }
 126
 127 you would use git-rev-list and git-diff-tree like this:
 128
 129         $ git-rev-list HEAD |
 130           git-diff-tree --stdin -v -p -S'if (frotz) {
 131                 nitfol();
 132         }'
 133
 134 We have already talked about the "--stdin" form of git-diff-tree
 135 command that reads the list of commits and compares each commit
 136 with its parents.  The git-whatchanged command internally runs
 137 the equivalent of the above command, and can be used like this:
 138
 139         $ git-whatchanged -p -S'if (frotz) {
 140                 nitfol();
 141         }'
 142
 143 When the -S option is used, git-diff-tree command outputs
 144 differences between two commits only if one tree has the
 145 specified string in a file and the corresponding file in the
 146 other tree does not.  The above example looks for a commit that
 147 has the "if" statement in it in a file, but its parent commit
 148 does not have it in the same shape in the corresponding file (or
 149 the other way around, where the parent has it and the commit
 150 does not), and the differences between them are shown, along
 151 with the commit message (thanks to the -v flag).  It does not
 152 show anything for commits that do not touch this "if" statement.
 153
 154 Also, in the original context, the same statement might have
 155 appeared at first in a different file and later the file was
 156 renamed to "a-file.c".  CVS annotate would not help you to go
 157 back across such a rename, but GIT would still help you in such
 158 a situation.  For that, you can give the -C flag to
 159 git-diff-tree, like this:
 160
 161         $ git-whatchanged -p -C -S'if (frotz) {
 162                 nitfol();
 163         }'
 164
 165 When the -C flag is used, file renames and copies are followed.
 166 So if the "if" statement in question happens to be in "a-file.c"
 167 in the current HEAD commit, even if the file was originally
 168 called "o-file.c" and then renamed in an earlier commit, or if
 169 the file was created by copying an existing "o-file.c" in an
 170 earlier commit, you will not lose track.  If the "if" statement
 171 did not change across such rename or copy, then the commit that
 172 does rename or copy would not show in the output, and if the
 173 "if" statement was modified while the file was still called
 174 "o-file.c", it would find the commit that changed the statement
 175 when it was in "o-file.c".
 176
 177 [ BTW, the current versions of "git-diff-tree -C" is not eager
 178   enough to find copies, and it will miss the fact that a-file.c
 179   was created by copying o-file.c unless o-file.c was somehow
 180   changed in the same commit.]
 181
 182 You can use the --pickaxe-all flag in addition to the -S flag.
 183 This causes the differences from all the files contained in
 184 those two commits, not just the differences between the files
 185 that contain this changed "if" statement:
 186
 187         $ git-whatchanged -p -C -S'if (frotz) {
 188                 nitfol();
 189         }' --pickaxe-all
 190
 191 [ Side note.  This option is called "--pickaxe-all" because -S
 192   option is internally called "pickaxe", a tool for software
 193   archaeologists.]