-Git for CVS users
+git for CVS users
=================
Ok, so you're a CVS user. That's ok, it's a treatable condition, and the
already.
The thing about CVS is that it absolutely sucks as a source control
-manager, and you'll thus be happy with almost anything else. Git,
-however, may be a bit _too_ different (read: "good") for your taste, and
+manager, and you'll thus be happy with almost anything else. git,
+however, may be a bit 'too' different (read: "good") for your taste, and
does a lot of things differently.
One particular suckage of CVS is very hard to work around: CVS is
-basically a tool for tracking _file_ history, while git is a tool for
-tracking _project_ history. This sometimes causes problems if you are
+basically a tool for tracking 'file' history, while git is a tool for
+tracking 'project' history. This sometimes causes problems if you are
used to doing very strange things in CVS, in particular if you're doing
-things like making branches of just a subset of the project. Git can't
+things like making branches of just a subset of the project. git can't
track that, since git never tracks things on the level of an individual
file, only on the whole project level.
The good news is that most people don't do that, and in fact most sane
people think it's a bug in CVS that makes it tag (and check in changes)
one file at a time. So most projects you'll ever see will use CVS
-_as_if_ it was sane. In which case you'll find it very easy indeed to
-move over to Git.
+'as if' it was sane. In which case you'll find it very easy indeed to
+move over to git.
-First off: this is not a git tutorial. See Documentation/tutorial.txt
-for how git actually works. This is more of a random collection of
-gotcha's and notes on converting from CVS to git.
+First off: this is not a git tutorial. See
+link:tutorial.html[Documentation/tutorial.txt] for how git
+actually works. This is more of a random collection of gotcha's
+and notes on converting from CVS to git.
Second: CVS has the notion of a "repository" as opposed to the thing
that you're actually working in (your working directory, or your
-"checked out tree"). Git does not have that notion at all, and all git
-working directories _are_ the repositories. However, you can easily
+"checked out tree"). git does not have that notion at all, and all git
+working directories 'are' the repositories. However, you can easily
emulate the CVS model by having one special "global repository", which
people can synchronize with. See details later, but in the meantime
just keep in mind that with git, every checked out working tree will
how to commit stuff etc in git) is to create a git'ified version of your
CVS archive.
-Happily, that's very easy indeed. Git will do it for you, although git
+Happily, that's very easy indeed. git will do it for you, although git
will need the help of a program called "cvsps":
http://www.cobite.com/cvsps/
which is not actually related to git at all, but which makes CVS usage
look almost sane (ie you almost certainly want to have it even if you
-decide to stay with CVS). However, git will want at _least_ version 2.1
+decide to stay with CVS). However, git will want 'at least' version 2.1
of cvsps (available at the address above), and in fact will currently
refuse to work with anything else.
there that can be used to get equivalent information (see the git
mailing list archives for details).
-Git has a couple of alternatives, though, that you may find sufficient
+git has a couple of alternatives, though, that you may find sufficient
or even superior depending on your use. One is called "git-whatchanged"
(for obvious reasons) and the other one is called "pickaxe" ("a tool for
-the software archeologist").
+the software archaeologist").
The "git-whatchanged" script is a truly trivial script that can give you
a good overview of what has changed in a file or a directory (or an
nitfol();
}'
-We have already talked about the "--stdin" form of git-diff-tree
+We have already talked about the "\--stdin" form of git-diff-tree
command that reads the list of commits and compares each commit
-with its parents. The git-whatchanged command internally runs
+with its parents (otherwise you should go back and read the tutorial).
+The git-whatchanged command internally runs
the equivalent of the above command, and can be used like this:
$ git-whatchanged -p -S'if (frotz) {
Also, in the original context, the same statement might have
appeared at first in a different file and later the file was
renamed to "a-file.c". CVS annotate would not help you to go
-back across such a rename, but GIT would still help you in such
+back across such a rename, but git would still help you in such
a situation. For that, you can give the -C flag to
git-diff-tree, like this:
"o-file.c", it would find the commit that changed the statement
when it was in "o-file.c".
-[ BTW, the current versions of "git-diff-tree -C" is not eager
+NOTE: The current version of "git-diff-tree -C" is not eager
enough to find copies, and it will miss the fact that a-file.c
was created by copying o-file.c unless o-file.c was somehow
- changed in the same commit.]
+ changed in the same commit.
You can use the --pickaxe-all flag in addition to the -S flag.
This causes the differences from all the files contained in
nitfol();
}' --pickaxe-all
-[ Side note. This option is called "--pickaxe-all" because -S
+NOTE: This option is called "--pickaxe-all" because -S
option is internally called "pickaxe", a tool for software
- archaeologists.]
+ archaeologists.