doing.
The core git is often called "plumbing", with the prettier user
-interfaces on top of it called "porcelain". You may want to know what
-the plumbing does for when the porcelain isn't flushing...
+interfaces on top of it called "porcelain". You may not want to use the
+plumbing directly very often, but it can be good to know what the
+plumbing does for when the porcelain isn't flushing...
Creating a git archive
one for a totally new project, or an existing working tree that you want
to import into git.
-For our first example, we're going to start a totally new arhive from
+For our first example, we're going to start a totally new archive from
scratch, with no pre-existing files, and we'll call it "git-tutorial".
To start up, create a subdirectory for it, change into that
subdirectory, and initialize the git infrastructure with "git-init-db":
defaulting to local storage area
-which is just gits way of saying that you haven't been doing anything
+which is just git's way of saying that you haven't been doing anything
strange, and that it will have created a local .git directory setup for
your new project. You will now have a ".git" directory, and you can
inspect that with "ls". For your new empty project, ls should show you
- a symlink called HEAD, pointing to "refs/heads/master"
Don't worry about the fact that the file that the HEAD link points to
- dosn't even exist yet - you haven't created the commit that will
+ doesn't even exist yet - you haven't created the commit that will
start your HEAD development branch yet.
- a subdirectory called "objects", which will contain all the git SHA1
One note: the special "master" head is the default branch, which is
why the .git/HEAD file was created as a symlink to it even if it
- doesn't yet exist. Bascially, the HEAD link is supposed to always
+ doesn't yet exist. Basically, the HEAD link is supposed to always
point to the branch you are working on right now, and you always
start out expecting to work on the "master" branch.
and you have now told git to track those two files.
In fact, as you did that, if you now look into your object directory,
-you'll notice that git will have added two ne wobjects to the object
+you'll notice that git will have added two new objects to the object
store. If you did exactly the steps above, you should now be able to do
ls .git/objects/??/*
more than the contents of your file "a".
[ Digression: don't confuse that object with the file "a" itself. The
-object is literally just those specific _contents_ of the file, and
-however much you later change the contents in file "a", the object we
-just looked at will never change. Objects are immutable. ]
+ object is literally just those specific _contents_ of the file, and
+ however much you later change the contents in file "a", the object we
+ just looked at will never change. Objects are immutable. ]
Anyway, as we mentioned previously, you normally never actually take a
look at the objects themselves, and typing long 40-character hex SHA1
you have not actually really "checked in" your files into git so far,
you've only _told_ git about them.
-However, since git knows about them, you can how start using some of the
+However, since git knows about them, you can now start using some of the
most basic git commands to manipulate the files or look at their status.
In particular, let's not even check in the two files into git yet, we'll
---------------
Remember how we did the "git-update-cache" on file "a" and then we
-changed "a" afterwards, and could compare the new state of "a" with the
+changed "a" afterward, and could compare the new state of "a" with the
state we saved in the index file?
Further, remember how I said that "git-write-tree" writes the contents
Unlike "git-diff-files", which showed the difference between the index
file and the working directory, "git-diff-cache" shows the differences
-between a committed _tree_ and the index file. In other words,
-git-diff-cache wants a tree to be diffed against, and before we did the
-commit, we couldn't do that, because we didn't have anything to diff
-against.
+between a committed _tree_ and either the the index file or the working
+directory. In other words, git-diff-cache wants a tree to be diffed
+against, and before we did the commit, we couldn't do that, because we
+didn't have anything to diff against.
But now we can do
(where "-p" has the same meaning as it did in git-diff-files), and it
will show us the same difference, but for a totally different reason.
-Now we're not comparing against the index file, we're comparing against
-the tree we just wrote. It just so happens that those two are obviously
-the same.
-
-"git-diff-cache" also has a specific flag "--cached", which is used to
-tell it to show the differences purely with the index file, and ignore
-the current working directory state entirely. Since we just wrote the
-index file to HEAD, doing "git-diff-cache --cached -p HEAD" should thus
-return an empty set of differences, and that's exactly what it does.
+Now we're comparing the working directory not against the index file,
+but against the tree we just wrote. It just so happens that those two
+are obviously the same, so we get the same result.
+
+In other words, "git-diff-cache" normally compares a tree against the
+working directory, but when given the "--cached" flag, it is told to
+instead compare against just the index cache contents, and ignore the
+current working directory state entirely. Since we just wrote the index
+file to HEAD, doing "git-diff-cache --cached -p HEAD" should thus return
+an empty set of differences, and that's exactly what it does.
+
+[ Digression: "git-diff-cache" really always uses the index for its
+ comparisons, and saying that it compares a tree against the working
+ directory is thus not strictly accurate. In particular, the list of
+ files to compare (the "meta-data") _always_ comes from the index file,
+ regardless of whether the --cached flag is used or not. The --cached
+ flag really only determines whether the file _contents_ to be compared
+ come from the working directory or not.
+
+ This is not hard to understand, as soon as you realize that git simply
+ never knows (or cares) about files that it is not told about
+ explicitly. Git will never go _looking_ for files to compare, it
+ expects you to tell it what the files are, and that's what the index
+ is there for. ]
However, our next step is to commit the _change_ we did, and again, to
-understand what's going on, keep in mind the difference between "workign
+understand what's going on, keep in mind the difference between "working
directory contents", "index file" and "committed tree". We have changes
in the working directory that we want to commit, and we always have to
work through the index file, so the first thing we need to do is to
Now, since we've updated "a" in the index, we can commit the new
version. We could do it by writing the tree by hand, and committing the
tree (this time we'd have to use the "-p HEAD" flag to tell commit that
-the HEAD was the _parent_ fo the new commit, and that this wasn't an
+the HEAD was the _parent_ of the new commit, and that this wasn't an
initial commit any more), but the fact is, git has a simple helper
script for doing all of the non-initial commits that does all of this
for you, and starts up an editor to let you write your commit message
yourself, so let's just use that:
- git-commit-script
+ git commit
Write whatever message you want, and all the lines that start with '#'
will be pruned out, and the rest will be used as the commit message for
so big that it's considered a whole new file, since the diff is actually
bigger than the file. So the helpful comments that git-commit-script
tells you for this example will say that you deleted and re-created the
-file "a". For a less contrieved example, these things are usually more
+file "a". For a less contrived example, these things are usually more
obvious).
You've now made your first real git commit. And if you're interested in
included with git which does exactly this, and shows a log of recent
activity.
-To see the whole history of our pitiful little git-tutorial project, we
+To see the whole history of our pitiful little git-tutorial project, you
can do
- git-whatchanged -p --root HEAD
+ git log
+
+which shows just the log messages, or if we want to see the log together
+with the associated patches use the more complex (and much more
+powerful)
+
+ git-whatchanged -p --root
+
+and you will see exactly what has changed in the repository over its
+short history.
-(the "--root" flag is a flag to git-diff-tree to tell it to show the
-initial aka "root" commit as a diff too), and you will see exactly what
-has changed in the repository over its short history.
+[ Side note: the "--root" flag is a flag to git-diff-tree to tell it to
+ show the initial aka "root" commit too. Normally you'd probably not
+ want to see the initial import diff, but since the tutorial project
+ was started from scratch and is so small, we use it to make the result
+ a bit more interesting ]
-With that, you should now be having some incling of what git does, and
+With that, you should now be having some inkling of what git does, and
can explore on your own.
+
+ Copying archives
+ -----------------
+
+Git archives are normally totally self-sufficient, and it's worth noting
+that unlike CVS, for example, there is no separate notion of
+"repository" and "working tree". A git repository normally _is_ the
+working tree, with the local git information hidden in the ".git"
+subdirectory. There is nothing else. What you see is what you got.
+
+[ Side note: you can tell git to split the git internal information from
+ the directory that it tracks, but we'll ignore that for now: it's not
+ how normal projects work, and it's really only meant for special uses.
+ So the mental model of "the git information is always tied directly to
+ the working directory that it describes" may not be technically 100%
+ accurate, but it's a good model for all normal use ]
+
+This has two implications:
+
+ - if you grow bored with the tutorial archive you created (or you've
+ made a mistake and want to start all over), you can just do simple
+
+ rm -rf git-tutorial
+
+ and it will be gone. There's no external repository, and there's no
+ history outside of the project you created.
+
+ - if you want to move or duplicate a git archive, you can do so. There
+ is no "git clone" command: if you want to create a copy of your
+ archive (with all the full history that went along with it), you can
+ do so with a regular "cp -a git-tutorial new-git-tutorial".
+
+ Note that when you've moved or copied a git archive, your git index
+ file (which caches various information, notably some of the "stat"
+ information for the files involved) will likely need to be refreshed.
+ So after you do a "cp -a" to create a new copy, you'll want to do
+
+ git-update-cache --refresh
+
+ to make sure that the index file is up-to-date in the new one.
+
+Note that the second point is true even across machines. You can
+duplicate a remote git archive with _any_ regular copy mechanism, be it
+"scp", "rsync" or "wget".
+
+When copying a remote repository, you'll want to at a minimum update the
+index cache when you do this, and especially with other peoples
+repositories you often want to make sure that the index cache is in some
+known state (you don't know _what_ they've done and not yet checked in),
+so usually you'll precede the "git-update-cache" with a
+
+ git-read-tree HEAD
+ git-update-cache --refresh
+
+which will force a total index re-build from the tree pointed to by
+HEAD.
+
+In fact, many public remote repositories will not contain any of the
+checked out files or even an index file, and will _only_ contain the
+actual core git files. Such a repository usually doesn't even have the
+".git" subdirectory, but has all the git files directly in the
+repository.
+
+To create your own local live copy of such a "raw" git repository, you'd
+first create your own subdirectory for the project, and then copy the
+raw repository contents into the ".git" directory. For example, to
+create your own copy of the git repository, you'd do the following
+
+ mkdir my-git
+ cd my-git
+ rsync -rL rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/git.git/ .git
+
+followed by
+
+ git-read-tree HEAD
+
+to populate the index. However, now you have populated the index, and
+you have all the git internal files, but you will notice that you don't
+actually have any of the _working_directory_ files to work on. To get
+those, you'd check them out with
+
+ git-checkout-cache -u -a
+
+where the "-u" flag means that you want the checkout to keep the index
+up-to-date (so that you don't have to refresh it afterward), and the
+"-a" file means "check out all files" (if you have a stale copy or an
+older version of a checked out tree you may also need to add the "-f"
+file first, to tell git-checkout-cache to _force_ overwriting of any old
+files).
+
+You have now successfully copied somebody else's (mine) remote
+repository, and checked it out.
+
[ to be continued.. cvs2git, tagging versions, branches, merging.. ]