X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=Documentation%2Ftutorial.txt;h=edd91cbbe42bec1ee406dd95d82832575d89d3a6;hb=58e3fb40f7ca1c28f9105c15166884f80bb22e55;hp=8d999b02de6a7e37f624ed0ee2d8541b32a58726;hpb=953e5842f8fcd40c3e7013a9793746719016db1b;p=git.git diff --git a/Documentation/tutorial.txt b/Documentation/tutorial.txt index 8d999b02..edd91cbb 100644 --- a/Documentation/tutorial.txt +++ b/Documentation/tutorial.txt @@ -1,6 +1,5 @@ A short git tutorial ==================== -v0.99.5, Aug 2005 Introduction ------------ @@ -19,7 +18,20 @@ doing. The core git is often called "plumbing", with the prettier user 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... +plumbing does for when the porcelain isn't flushing. + +The material presented here often goes deep describing how things +work internally. If you are mostly interested in using git as a +SCM, you can skip them during your first pass. + +[NOTE] +And those "too deep" descriptions are often marked as Note. + +[NOTE] +If you are already familiar with another version control system, +like CVS, you may want to take a look at +link:everyday.html[Everyday GIT in 20 commands or so] first +before reading this. Creating a git repository @@ -37,14 +49,16 @@ To start up, create a subdirectory for it, change into that subdirectory, and initialize the git infrastructure with `git-init-db`: ------------------------------------------------ -mkdir git-tutorial -cd git-tutorial -git-init-db +$ mkdir git-tutorial +$ cd git-tutorial +$ git-init-db ------------------------------------------------ to which git will reply - defaulting to local storage area +---------------- +defaulting to local storage area +---------------- 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 @@ -52,7 +66,9 @@ your new project. You will now have a `.git` directory, and you can inspect that with `ls`. For your new empty project, it should show you three entries, among other things: - - a symlink called `HEAD`, pointing to `refs/heads/master` + - a symlink called `HEAD`, pointing to `refs/heads/master` (if your + platform does not have native symlinks, it is a file containing the + line "ref: refs/heads/master") + Don't worry about the fact that the file that the `HEAD` link points to doesn't even exist yet -- you haven't created the commit that will @@ -113,8 +129,8 @@ in your git repository. We'll start off with a few bad examples, just to get a feel for how this works: ------------------------------------------------ -echo "Hello World" >hello -echo "Silly example" >example +$ echo "Hello World" >hello +$ echo "Silly example" >example ------------------------------------------------ you have now created two files in your working tree (aka 'working directory'), but to @@ -126,9 +142,9 @@ actually check in your hard work, you will have to go through two steps: - commit that index file as an object. The first step is trivial: when you want to tell git about any changes -to your working tree, you use the `git-update-cache` program. That +to your working tree, you use the `git-update-index` program. That program normally just takes a list of filenames you want to update, but -to avoid trivial mistakes, it refuses to add new entries to the cache +to avoid trivial mistakes, it refuses to add new entries to the index (or remove existing ones) unless you explicitly tell it that you're adding a new entry with the `\--add` flag (or removing an entry with the `\--remove`) flag. @@ -136,7 +152,7 @@ adding a new entry with the `\--add` flag (or removing an entry with the So to populate the index with the two files you just created, you can do ------------------------------------------------ -git-update-cache --add hello example +$ git-update-index --add hello example ------------------------------------------------ and you have now told git to track those two files. @@ -145,12 +161,17 @@ In fact, as you did that, if you now look into your object directory, you'll notice that git will have added two new objects to the object database. If you did exactly the steps above, you should now be able to do - ls .git/objects/??/* + +---------------- +$ ls .git/objects/??/* +---------------- and see two files: - .git/objects/55/7db03de997c86a4a028e1ebd3a1ceb225be238 - .git/objects/f2/4c74a2e500f5ee1332c86b94199f52b1d1d962 +---------------- +.git/objects/55/7db03de997c86a4a028e1ebd3a1ceb225be238 +.git/objects/f2/4c74a2e500f5ee1332c86b94199f52b1d1d962 +---------------- which correspond with the objects with names of 557db... and f24c7.. respectively. @@ -158,13 +179,17 @@ respectively. If you want to, you can use `git-cat-file` to look at those objects, but you'll have to use the object name, not the filename of the object: - git-cat-file -t 557db03de997c86a4a028e1ebd3a1ceb225be238 +---------------- +$ git-cat-file -t 557db03de997c86a4a028e1ebd3a1ceb225be238 +---------------- where the `-t` tells `git-cat-file` to tell you what the "type" of the -object is. Git will tell you that you have a "blob" object (ie just a +object is. git will tell you that you have a "blob" object (ie just a regular file), and you can see the contents with - git-cat-file "blob" 557db03 +---------------- +$ git-cat-file "blob" 557db03 +---------------- which will print out "Hello World". The object 557db03 is nothing more than the contents of your file `hello`. @@ -183,11 +208,11 @@ hexadecimal digits in most places. Anyway, as we mentioned previously, you normally never actually take a look at the objects themselves, and typing long 40-character hex names is not something you'd normally want to do. The above digression -was just to show that `git-update-cache` did something magical, and +was just to show that `git-update-index` did something magical, and actually saved away the contents of your files into the git object database. -Updating the cache did something else too: it created a `.git/index` +Updating the index did something else too: it created a `.git/index` file. This is the index that describes your current working tree, and something you should be very aware of. Again, you normally never worry about the index file itself, but you should be aware of the fact that @@ -201,7 +226,7 @@ In particular, let's not even check in the two files into git yet, we'll start off by adding another line to `hello` first: ------------------------------------------------ -echo "It's a new day for git" >>hello +$ echo "It's a new day for git" >>hello ------------------------------------------------ and you can now, since you told git about the previous state of `hello`, ask @@ -209,7 +234,7 @@ git what has changed in the tree compared to your old index, using the `git-diff-files` command: ------------ -git-diff-files +$ git-diff-files ------------ Oops. That wasn't very readable. It just spit out its own internal @@ -221,13 +246,9 @@ To make it readable, we can tell git-diff-files to output the differences as a patch, using the `-p` flag: ------------ -git-diff-files -p ------------- - -which will spit out - ------------- +$ git-diff-files -p diff --git a/hello b/hello +index 557db03..263414f 100644 --- a/hello +++ b/hello @@ -1 +1,2 @@ @@ -244,6 +265,17 @@ tree. That's very useful. A common shorthand for `git-diff-files -p` is to just write `git diff`, which will do the same thing. +------------ +$ git diff +diff --git a/hello b/hello +index 557db03..263414f 100644 +--- a/hello ++++ b/hello +@@ -1 +1,2 @@ + Hello World ++It's a new day for git +------------ + Committing git state -------------------- @@ -262,13 +294,15 @@ filenames with their contents (and their permissions), and we're creating the equivalent of a git "directory" object: ------------------------------------------------ -git-write-tree +$ git-write-tree ------------------------------------------------ and this will just output the name of the resulting tree, in this case (if you have done exactly as I've described) it should be - 8988da15d077d4829fc51d8544c097def6644dbb +---------------- +8988da15d077d4829fc51d8544c097def6644dbb +---------------- which is another incomprehensible object name. Again, if you want to, you can use `git-cat-file -t 8988d\...` to see that this time the object @@ -290,18 +324,23 @@ also wants to get a commit message on its standard input, and it will write out the resulting object name for the commit to its standard output. -And this is where we start using the `.git/HEAD` file. The `HEAD` file is -supposed to contain the reference to the top-of-tree, and since that's -exactly what `git-commit-tree` spits out, we can do this all with a simple -shell pipeline: +And this is where we create the `.git/refs/heads/master` file +which is pointed at by `HEAD`. This file is supposed to contain +the reference to the top-of-tree of the master branch, and since +that's exactly what `git-commit-tree` spits out, we can do this +all with a sequence of simple shell commands: ------------------------------------------------ -echo "Initial commit" | git-commit-tree $(git-write-tree) > .git/HEAD +$ tree=$(git-write-tree) +$ commit=$(echo 'Initial commit' | git-commit-tree $tree) +$ git-update-ref HEAD $commit ------------------------------------------------ which will say: - Committing initial tree 8988da15d077d4829fc51d8544c097def6644dbb +---------------- +Committing initial tree 8988da15d077d4829fc51d8544c097def6644dbb +---------------- just to warn you about the fact that it created a totally new commit that is not related to anything else. Normally you do this only *once* @@ -318,7 +357,7 @@ instead, and it would have done the above magic scripting for you. Making a change --------------- -Remember how we did the `git-update-cache` on file `hello` and then we +Remember how we did the `git-update-index` on file `hello` and then we changed `hello` afterward, and could compare the new state of `hello` with the state we saved in the index file? @@ -333,18 +372,20 @@ As before, if we do `git-diff-files -p` in our git-tutorial project, we'll still see the same difference we saw last time: the index file hasn't changed by the act of committing anything. However, now that we have committed something, we can also learn to use a new command: -`git-diff-cache`. +`git-diff-index`. Unlike `git-diff-files`, which showed the difference between the index -file and the working tree, `git-diff-cache` shows the differences +file and the working tree, `git-diff-index` shows the differences between a committed *tree* and either the index file or the working -tree. In other words, `git-diff-cache` wants a tree to be diffed +tree. In other words, `git-diff-index` 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 - git-diff-cache -p HEAD +---------------- +$ git-diff-index -p HEAD +---------------- (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. @@ -355,20 +396,22 @@ are obviously the same, so we get the same result. Again, because this is a common operation, you can also just shorthand it with - git diff HEAD +---------------- +$ git diff HEAD +---------------- which ends up doing the above for you. -In other words, `git-diff-cache` normally compares a tree against the +In other words, `git-diff-index` normally compares a tree against the working tree, but when given the `\--cached` flag, it is told to instead compare against just the index cache contents, and ignore the current working tree state entirely. Since we just wrote the index -file to HEAD, doing `git-diff-cache \--cached -p HEAD` should thus return +file to HEAD, doing `git-diff-index \--cached -p HEAD` should thus return an empty set of differences, and that's exactly what it does. [NOTE] ================ -`git-diff-cache` really always uses the index for its +`git-diff-index` really always uses the index for its comparisons, and saying that it compares a tree against the working tree is thus not strictly accurate. In particular, the list of files to compare (the "meta-data") *always* comes from the index file, @@ -378,7 +421,7 @@ come from the working tree 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 +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. ================ @@ -391,7 +434,7 @@ work through the index file, so the first thing we need to do is to update the index cache: ------------------------------------------------ -git-update-cache hello +$ git-update-index hello ------------------------------------------------ (note how we didn't need the `\--add` flag this time, since git knew @@ -399,9 +442,9 @@ about the file already). Note what happens to the different `git-diff-\*` versions here. After we've updated `hello` in the index, `git-diff-files -p` now shows no -differences, but `git-diff-cache -p HEAD` still *does* show that the +differences, but `git-diff-index -p HEAD` still *does* show that the current state is different from the state we committed. In fact, now -`git-diff-cache` shows the same difference whether we use the `--cached` +`git-diff-index` shows the same difference whether we use the `--cached` flag or not, since now the index is coherent with the working tree. Now, since we've updated `hello` in the index, we can commit the new @@ -412,7 +455,7 @@ this wasn't an initial commit any more), but you've done that once already, so let's just use the helpful script this time: ------------------------------------------------ -git commit +$ git commit ------------------------------------------------ which starts an editor for you to write the commit message and tells you @@ -421,7 +464,7 @@ a bit about what you have done. 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 the change. If you decide you don't want to commit anything after all at -this point (you can continue to edit things and update the cache), you +this point (you can continue to edit things and update the index), you can just leave an empty message. Otherwise `git commit` will commit the change for you. @@ -429,11 +472,11 @@ You've now made your first real git commit. And if you're interested in looking at what `git commit` really does, feel free to investigate: it's a few very simple shell scripts to generate the helpful (?) commit message headers, and a few one-liners that actually do the -commit itself (`git-commit-script`). +commit itself (`git-commit`). -Checking it out ---------------- +Inspecting Changes +------------------ While creating changes is useful, it's even more useful if you can tell later what changed. The most useful command for this is another of the @@ -445,11 +488,48 @@ give it just a single commit object, and it will figure out the parent of that commit itself, and show the difference directly. Thus, to get the same diff that we've already seen several times, we can now do - git-diff-tree -p HEAD +---------------- +$ git-diff-tree -p HEAD +---------------- (again, `-p` means to show the difference as a human-readable patch), and it will show what the last commit (in `HEAD`) actually changed. +[NOTE] +============ +Here is an ASCII art by Jon Loeliger that illustrates how +various diff-\* commands compare things. + + diff-tree + +----+ + | | + | | + V V + +-----------+ + | Object DB | + | Backing | + | Store | + +-----------+ + ^ ^ + | | + | | diff-index --cached + | | + diff-index | V + | +-----------+ + | | Index | + | | "cache" | + | +-----------+ + | ^ + | | + | | diff-files + | | + V V + +-----------+ + | Working | + | Directory | + +-----------+ +============ + More interestingly, you can also give `git-diff-tree` the `-v` flag, which tells it to also show the commit message and author and date of the commit, and you can tell it to show a whole series of diffs. @@ -465,13 +545,17 @@ activities. To see the whole history of our pitiful little git-tutorial project, you can do - git log +---------------- +$ 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 +---------------- +$ git-whatchanged -p --root +---------------- and you will see exactly what has changed in the repository over its short history. @@ -490,11 +574,11 @@ can explore on your own. Most likely, you are not directly using the core git Plumbing commands, but using Porcelain like Cogito on top of it. Cogito works a bit differently and you usually do not -have to run `git-update-cache` yourself for changed files (you +have to run `git-update-index` yourself for changed files (you do tell underlying git about additions and removals via `cg-add` and `cg-rm` commands). Just before you make a commit with `cg-commit`, Cogito figures out which files you modified, -and runs `git-update-cache` on them for you. +and runs `git-update-index` on them for you. Tagging a version @@ -507,14 +591,16 @@ it in the `.git/refs/tags/` subdirectory instead of calling it a `head`. So the simplest form of tag involves nothing more than ------------------------------------------------ -git tag my-first-tag +$ git tag my-first-tag ------------------------------------------------ which just writes the current `HEAD` into the `.git/refs/tags/my-first-tag` file, after which point you can then use this symbolic name for that particular state. You can, for example, do - git diff my-first-tag +---------------- +$ git diff my-first-tag +---------------- to diff your current state against that tag (which at this point will obviously be an empty diff, but if you continue to develop and commit @@ -528,7 +614,9 @@ you really did that tag. You create these annotated tags with either the `-a` or `-s` flag to `git tag`: - git tag -s +---------------- +$ git tag -s +---------------- which will sign the current `HEAD` (but you can also give it another argument that specifies the thing to tag, ie you could have tagged the @@ -544,8 +632,8 @@ name for the state at that point. Copying repositories -------------------- -Git repositories are normally totally self-sufficient, and it's worth noting -that unlike CVS, for example, there is no separate notion of +git repositories are normally totally self-sufficient and relocatable +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. @@ -562,8 +650,10 @@ This has two implications: - if you grow bored with the tutorial repository you created (or you've made a mistake and want to start all over), you can just do simple - - rm -rf git-tutorial ++ +---------------- +$ rm -rf git-tutorial +---------------- + and it will be gone. There's no external repository, and there's no history outside the project you created. @@ -578,8 +668,10 @@ Note that when you've moved or copied a git repository, 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 ++ +---------------- +$ git-update-index --refresh +---------------- + in the new repository to make sure that the index file is up-to-date. @@ -591,28 +683,32 @@ 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 +so usually you'll precede the `git-update-index` with a - git-read-tree --reset HEAD - git-update-cache --refresh +---------------- +$ git-read-tree --reset HEAD +$ git-update-index --refresh +---------------- which will force a total index re-build from the tree pointed to by `HEAD`. -It resets the index contents to `HEAD`, and then the `git-update-cache` +It resets the index contents to `HEAD`, and then the `git-update-index` makes sure to match up all index entries with the checked-out files. If the original repository had uncommitted changes in its -working tree, `git-update-cache --refresh` notices them and +working tree, `git-update-index --refresh` notices them and tells you they need to be updated. The above can also be written as simply - git reset +---------------- +$ git reset +---------------- and in fact a lot of the common git command combinations can be scripted -with the `git xyz` interfaces, and you can learn things by just looking -at what the `git-*-script` scripts do (`git reset` is the above two lines -implemented in `git-reset-script`, but some things like `git status` and -`git commit` are slightly more complex scripts around the basic git -commands). +with the `git xyz` interfaces. You can learn things by just looking +at what the various git scripts do. For example, `git reset` is the +above two lines implemented in `git-reset`, but some things like +`git status` and `git commit` are slightly more complex scripts around +the basic git commands. Many (most?) public remote repositories will not contain any of the checked out files or even an index file, and will *only* contain the @@ -625,33 +721,41 @@ 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/git/git.git/ .git +---------------- +$ mkdir my-git +$ cd my-git +$ rsync -rL rsync://rsync.kernel.org/pub/scm/git/git.git/ .git +---------------- followed by - git-read-tree HEAD +---------------- +$ 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 tree files to work on. To get those, you'd check them out with - git-checkout-cache -u -a +---------------- +$ git-checkout-index -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` flag 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` -flag first, to tell git-checkout-cache to *force* overwriting of any old +flag first, to tell git-checkout-index to *force* overwriting of any old files). Again, this can all be simplified with - git clone rsync://rsync.kernel.org/pub/scm/git/git.git/ my-git - cd my-git - git checkout +---------------- +$ git clone rsync://rsync.kernel.org/pub/scm/git/git.git/ my-git +$ cd my-git +$ git checkout +---------------- which will end up doing all of the above for you. @@ -679,7 +783,7 @@ used earlier, and create a branch in it. You do that by simply just saying that you want to check out a new branch: ------------ -git checkout -b mybranch +$ git checkout -b mybranch ------------ will create a new branch based at the current `HEAD` position, and switch @@ -692,7 +796,9 @@ other point in the history than the current `HEAD`, you can do so by just telling `git checkout` what the base of the checkout would be. In other words, if you have an earlier tag or branch, you'd just do - git checkout -b mybranch earlier-commit +------------ +$ git checkout -b mybranch earlier-commit +------------ and it would create the new branch `mybranch` at the earlier commit, and check out the state at that time. @@ -700,17 +806,29 @@ and check out the state at that time. You can always just jump back to your original `master` branch by doing - git checkout master +------------ +$ git checkout master +------------ (or any other branch-name, for that matter) and if you forget which branch you happen to be on, a simple - ls -l .git/HEAD +------------ +$ ls -l .git/HEAD +------------ + +will tell you where it's pointing (Note that on platforms with bad or no +symlink support, you have to execute + +------------ +$ cat .git/HEAD +------------ -will tell you where it's pointing. To get the list of branches -you have, you can say +instead). To get the list of branches you have, you can say - git branch +------------ +$ git branch +------------ which is nothing more than a simple script around `ls .git/refs/heads`. There will be asterisk in front of the branch you are currently on. @@ -718,7 +836,9 @@ There will be asterisk in front of the branch you are currently on. Sometimes you may wish to create a new branch _without_ actually checking it out and switching to it. If so, just use the command - git branch [startingpoint] +------------ +$ git branch [startingpoint] +------------ which will simply _create_ the branch, but will not do anything further. You can then later -- once you decide that you want to actually develop @@ -736,13 +856,13 @@ being the same as the original `master` branch, let's make sure we're in that branch, and do some work there. ------------------------------------------------ -git checkout mybranch -echo "Work, work, work" >>hello -git commit -m 'Some work.' hello +$ git checkout mybranch +$ echo "Work, work, work" >>hello +$ git commit -m 'Some work.' hello ------------------------------------------------ Here, we just added another line to `hello`, and we used a shorthand for -both going a `git-update-cache hello` and `git commit` by just giving the +doing both `git-update-index hello` and `git commit` by just giving the filename directly to `git commit`. The `-m` flag is to give the commit log message from the command line. @@ -751,7 +871,7 @@ does some work in the original branch, and simulate that by going back to the master branch, and editing the same file differently there: ------------ -git checkout master +$ git checkout master ------------ Here, take a moment to look at the contents of `hello`, and notice how they @@ -759,9 +879,9 @@ don't contain the work we just did in `mybranch` -- because that work hasn't happened in the `master` branch at all. Then do ------------ -echo "Play, play, play" >>hello -echo "Lots of fun" >>example -git commit -m 'Some fun.' hello example +$ echo "Play, play, play" >>hello +$ echo "Lots of fun" >>example +$ git commit -m 'Some fun.' hello example ------------ since the master branch is obviously in a much better mood. @@ -770,7 +890,9 @@ Now, you've got two branches, and you decide that you want to merge the work done. Before we do that, let's introduce a cool graphical tool that helps you view what's going on: - gitk --all +---------------- +$ gitk --all +---------------- will show you graphically both of your branches (that's what the `\--all` means: normally it will just show you your current `HEAD`) and their @@ -780,14 +902,14 @@ source. Anyway, let's exit `gitk` (`^Q` or the File menu), and decide that we want to merge the work we did on the `mybranch` branch into the `master` branch (which is currently our `HEAD` too). To do that, there's a nice -script called `git resolve`, which wants to know which branches you want +script called `git merge`, which wants to know which branches you want to resolve and what the merge is all about: ------------ -git resolve HEAD mybranch "Merge work in mybranch" +$ git merge "Merge work in mybranch" HEAD mybranch ------------ -where the third argument is going to be used as the commit message if +where the first argument is going to be used as the commit message if the merge can be resolved automatically. Now, in this case we've intentionally created a situation where the @@ -795,12 +917,15 @@ merge will need to be fixed up by hand, though, so git will do as much of it as it can automatically (which in this case is just merge the `example` file, which had no differences in the `mybranch` branch), and say: - Simple merge failed, trying Automatic merge - Auto-merging hello. - merge: warning: conflicts during merge - ERROR: Merge conflict in hello. - fatal: merge program failed - Automatic merge failed, fix up by hand +---------------- + Trying really trivial in-index merge... + fatal: Merge requires file-level merging + Nope. + ... + Auto-merging hello + CONFLICT (content): Merge conflict in hello + Automatic merge failed/prevented; fix up by hand +---------------- which is way too verbose, but it basically tells you that it failed the really trivial merge ("Simple merge") and did an "Automatic merge" @@ -821,14 +946,14 @@ Work, work, work and once you're happy with your manual merge, just do a ------------ -git commit hello +$ git commit hello ------------ which will very loudly warn you that you're now committing a merge (which is correct, so never mind), and you can write a small merge message about your adventures in git-merge-land. -After you're done, start up `gitk --all` to see graphically what the +After you're done, start up `gitk \--all` to see graphically what the history looks like. Notice that `mybranch` still exists, and you can switch to it, and continue to work with it if you want to. The `mybranch` branch will not contain the merge, but next time you merge it @@ -840,11 +965,10 @@ environment, is `git show-branch`. ------------------------------------------------ $ git show-branch master mybranch -* [master] Merged "mybranch" changes. +* [master] Merge work in mybranch ! [mybranch] Some work. -- -+ [master] Merged "mybranch" changes. -+ [master~1] Some fun. ++ [master] Merge work in mybranch ++ [mybranch] Some work. ------------------------------------------------ @@ -859,23 +983,32 @@ All of them have plus `+` characters in the first column, which means they are now part of the `master` branch. Only the "Some work" commit has the plus `+` character in the second column, because `mybranch` has not been merged to incorporate these -commits from the master branch. +commits from the master branch. The string inside brackets +before the commit log message is a short name you can use to +name the commit. In the above example, 'master' and 'mybranch' +are branch heads. 'master~1' is the first parent of 'master' +branch head. Please see 'git-rev-parse' documentation if you +see more complex cases. Now, let's pretend you are the one who did all the work in `mybranch`, and the fruit of your hard work has finally been merged to the `master` branch. Let's go back to `mybranch`, and run resolve to get the "upstream changes" back to your branch. - git checkout mybranch - git resolve HEAD master "Merge upstream changes." +------------ +$ git checkout mybranch +$ git merge "Merge upstream changes." HEAD master +------------ This outputs something like this (the actual commit object names would be different) - Updating from ae3a2da... to a80b4aa.... - example | 1 + - hello | 1 + - 2 files changed, 2 insertions(+), 0 deletions(-) +---------------- +Updating from ae3a2da... to a80b4aa.... + example | 1 + + hello | 1 + + 2 files changed, 2 insertions(+), 0 deletions(-) +---------------- Because your branch did not contain anything more than what are already merged into the `master` branch, the resolve operation did @@ -883,15 +1016,15 @@ not actually do a merge. Instead, it just updated the top of the tree of your branch to that of the `master` branch. This is often called 'fast forward' merge. -You can run `gitk --all` again to see how the commit ancestry +You can run `gitk \--all` again to see how the commit ancestry looks like, or run `show-branch`, which tells you this. ------------------------------------------------ $ git show-branch master mybranch -! [master] Merged "mybranch" changes. - * [mybranch] Merged "mybranch" changes. +! [master] Merge work in mybranch + * [mybranch] Merge work in mybranch -- -++ [master] Merged "mybranch" changes. +++ [master] Merge work in mybranch ------------------------------------------------ @@ -901,14 +1034,16 @@ Merging external work It's usually much more common that you merge with somebody else than merging with your own branches, so it's worth pointing out that git makes that very easy too, and in fact, it's not that different from -doing a `git resolve`. In fact, a remote merge ends up being nothing +doing a `git merge`. In fact, a remote merge ends up being nothing more than "fetch the work from a remote repository into a temporary tag" -followed by a `git resolve`. +followed by a `git merge`. Fetching from a remote repository is done by, unsurprisingly, `git fetch`: - git fetch +---------------- +$ git fetch +---------------- One of the following transports can be used to name the repository to download from: @@ -946,19 +1081,20 @@ This transport is the same as SSH transport but uses `sh` to run both ends on the local machine instead of running other end on the remote machine via `ssh`. -GIT Native:: +git Native:: `git://remote.machine/path/to/repo.git/` + This transport was designed for anonymous downloading. Like SSH transport, it finds out the set of objects the downstream side lacks and transfers (close to) minimum set of objects. -HTTP(s):: +HTTP(S):: `http://remote.machine/path/to/repo.git/` + -HTTP and HTTPS transport are used only for downloading. They -first obtain the topmost commit object name from the remote site -by looking at `repo.git/info/refs` file, tries to obtain the +Downloader from http and https URL +first obtains the topmost commit object name from the remote site +by looking at the specified refname under `repo.git/refs/` directory, +and then tries to obtain the commit object by downloading from `repo.git/objects/xx/xxx\...` using the object name of that commit object. Then it reads the commit object to find out its parent commits and the associate @@ -967,13 +1103,15 @@ necessary objects. Because of this behaviour, they are sometimes also called 'commit walkers'. + The 'commit walkers' are sometimes also called 'dumb -transports', because they do not require any GIT aware smart -server like GIT Native transport does. Any stock HTTP server -would suffice. +transports', because they do not require any git aware smart +server like git Native transport does. Any stock HTTP server +that does not even support directory index would suffice. But +you must prepare your repository with `git-update-server-info` +to help dumb transport downloaders. + -There are (confusingly enough) `git-ssh-pull` and `git-ssh-push` +There are (confusingly enough) `git-ssh-fetch` and `git-ssh-upload` programs, which are 'commit walkers'; they outlived their -usefulness when GIT Native and SSH transports were introduced, +usefulness when git Native and SSH transports were introduced, and not used by `git pull` or `git push` scripts. Once you fetch from the remote repository, you `resolve` that @@ -983,7 +1121,9 @@ However -- it's such a common thing to `fetch` and then immediately `resolve`, that it's called `git pull`, and you can simply do - git pull +---------------- +$ git pull +---------------- and optionally give a branch-name for the remote end as a second argument. @@ -1001,7 +1141,9 @@ multiple working trees, but disk space is cheap these days. [NOTE] You could even pull from your own repository by -giving '.' as parameter to `git pull`. +giving '.' as parameter to `git pull`. This +is useful when you want to merge a local branch (or more, if you +are making an Octopus) into the current branch. It is likely that you will be pulling from the same remote repository from time to time. As a short hand, you can store @@ -1009,8 +1151,8 @@ the remote repository URL in a file under .git/remotes/ directory, like this: ------------------------------------------------ -mkdir -p .git/remotes/ -cat >.git/remotes/linus <<\EOF +$ mkdir -p .git/remotes/ +$ cat >.git/remotes/linus <<\EOF URL: http://www.kernel.org/pub/scm/git/git.git/ EOF ------------------------------------------------ @@ -1020,7 +1162,7 @@ The URL specified in such file can even be a prefix of a full URL, like this: ------------------------------------------------ -cat >.git/remotes/jgarzik <<\EOF +$ cat >.git/remotes/jgarzik <<\EOF URL: http://www.kernel.org/pub/scm/linux/git/jgarzik/ EOF ------------------------------------------------ @@ -1039,6 +1181,157 @@ the above are equivalent to: . `git pull http://www.kernel.org/pub/.../jgarzik/netdev-2.6.git e100` +How does the merge work? +------------------------ + +We said this tutorial shows what plumbing does to help you cope +with the porcelain that isn't flushing, but we so far did not +talk about how the merge really works. If you are following +this tutorial the first time, I'd suggest to skip to "Publishing +your work" section and come back here later. + +OK, still with me? To give us an example to look at, let's go +back to the earlier repository with "hello" and "example" file, +and bring ourselves back to the pre-merge state: + +------------ +$ git show-branch --more=3 master mybranch +! [master] Merge work in mybranch + * [mybranch] Merge work in mybranch +-- +++ [master] Merge work in mybranch +++ [master^2] Some work. +++ [master^] Some fun. +------------ + +Remember, before running `git merge`, our `master` head was at +"Some fun." commit, while our `mybranch` head was at "Some +work." commit. + +------------ +$ git checkout mybranch +$ git reset --hard master^2 +$ git checkout master +$ git reset --hard master^ +------------ + +After rewinding, the commit structure should look like this: + +------------ +$ git show-branch +* [master] Some fun. + ! [mybranch] Some work. +-- + + [mybranch] Some work. ++ [master] Some fun. +++ [mybranch^] New day. +------------ + +Now we are ready to experiment with the merge by hand. + +`git merge` command, when merging two branches, uses 3-way merge +algorithm. First, it finds the common ancestor between them. +The command it uses is `git-merge-base`: + +------------ +$ mb=$(git-merge-base HEAD mybranch) +------------ + +The command writes the commit object name of the common ancestor +to the standard output, so we captured its output to a variable, +because we will be using it in the next step. BTW, the common +ancestor commit is the "New day." commit in this case. You can +tell it by: + +------------ +$ git-name-rev $mb +my-first-tag +------------ + +After finding out a common ancestor commit, the second step is +this: + +------------ +$ git-read-tree -m -u $mb HEAD mybranch +------------ + +This is the same `git-read-tree` command we have already seen, +but it takes three trees, unlike previous examples. This reads +the contents of each tree into different 'stage' in the index +file (the first tree goes to stage 1, the second stage 2, +etc.). After reading three trees into three stages, the paths +that are the same in all three stages are 'collapsed' into stage +0. Also paths that are the same in two of three stages are +collapsed into stage 0, taking the SHA1 from either stage 2 or +stage 3, whichever is different from stage 1 (i.e. only one side +changed from the common ancestor). + +After 'collapsing' operation, paths that are different in three +trees are left in non-zero stages. At this point, you can +inspect the index file with this command: + +------------ +$ git-ls-files --stage +100644 7f8b141b65fdcee47321e399a2598a235a032422 0 example +100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello +100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello +100644 cc44c73eb783565da5831b4d820c962954019b69 3 hello +------------ + +In our example of only two files, we did not have unchanged +files so only 'example' resulted in collapsing, but in real-life +large projects, only small number of files change in one commit, +and this 'collapsing' tends to trivially merge most of the paths +fairly quickly, leaving only a handful the real changes in non-zero +stages. + +To look at only non-zero stages, use `\--unmerged` flag: + +------------ +$ git-ls-files --unmerged +100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello +100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello +100644 cc44c73eb783565da5831b4d820c962954019b69 3 hello +------------ + +The next step of merging is to merge these three versions of the +file, using 3-way merge. This is done by giving +`git-merge-one-file` command as one of the arguments to +`git-merge-index` command: + +------------ +$ git-merge-index git-merge-one-file hello +Auto-merging hello. +merge: warning: conflicts during merge +ERROR: Merge conflict in hello. +fatal: merge program failed +------------ + +`git-merge-one-file` script is called with parameters to +describe those three versions, and is responsible to leave the +merge results in the working tree. +It is a fairly straightforward shell script, and +eventually calls `merge` program from RCS suite to perform a +file-level 3-way merge. In this case, `merge` detects +conflicts, and the merge result with conflict marks is left in +the working tree.. This can be seen if you run `ls-files +--stage` again at this point: + +------------ +$ git-ls-files --stage +100644 7f8b141b65fdcee47321e399a2598a235a032422 0 example +100644 263414f423d0e4d70dae8fe53fa34614ff3e2860 1 hello +100644 06fa6a24256dc7e560efa5687fa84b51f0263c3a 2 hello +100644 cc44c73eb783565da5831b4d820c962954019b69 3 hello +------------ + +This is the state of the index file and the working file after +`git merge` returns control back to you, leaving the conflicting +merge for you to resolve. Notice that the path `hello` is still +unmerged, and what you see with `git diff` at this point is +differences since stage 2 (i.e. your version). + + Publishing your work -------------------- @@ -1077,19 +1370,23 @@ done only once. on the remote machine. The communication between the two over the network internally uses an SSH connection. -Your private repository's GIT directory is usually `.git`, but +Your private repository's git directory is usually `.git`, but your public repository is often named after the project name, i.e. `.git`. Let's create such a public repository for project `my-git`. After logging into the remote machine, create an empty directory: - mkdir my-git.git +------------ +$ mkdir my-git.git +------------ -Then, make that directory into a GIT repository by running +Then, make that directory into a git repository by running `git init-db`, but this time, since its name is not the usual `.git`, we do things slightly differently: - GIT_DIR=my-git.git git-init-db +------------ +$ GIT_DIR=my-git.git git-init-db +------------ Make sure this directory is available for others you want your changes to be pulled by via the transport of your choice. Also @@ -1113,7 +1410,9 @@ Your "public repository" is now ready to accept your changes. Come back to the machine you have your private repository. From there, run this command: - git push :/path/to/my-git.git master +------------ +$ git push :/path/to/my-git.git master +------------ This synchronizes your public repository to match the named branch head (i.e. `master` in this case) and objects reachable @@ -1123,7 +1422,9 @@ As a real example, this is how I update my public git repository. Kernel.org mirror network takes care of the propagation to other publicly visible machines: - git push master.kernel.org:/pub/scm/git/git.git/ +------------ +$ git push master.kernel.org:/pub/scm/git/git.git/ +------------ Packing your repository @@ -1136,7 +1437,9 @@ not so convenient to transport over the network. Since git objects are immutable once they are created, there is a way to optimize the storage by "packing them together". The command - git repack +------------ +$ git repack +------------ will do it for you. If you followed the tutorial examples, you would have accumulated about 17 objects in `.git/objects/??/` @@ -1160,7 +1463,9 @@ Our programs are always perfect ;-). Once you have packed objects, you do not need to leave the unpacked objects that are contained in the pack file anymore. - git prune-packed +------------ +$ git prune-packed +------------ would remove them for you. @@ -1215,12 +1520,13 @@ A recommended workflow for a "project lead" goes like this: 2. Prepare a public repository accessible to others. + If other people are pulling from your repository over dumb -transport protocols, you need to keep this repository 'dumb -transport friendly'. After `git init-db`, +transport protocols (HTTP), you need to keep this repository +'dumb transport friendly'. After `git init-db`, `$GIT_DIR/hooks/post-update` copied from the standard templates would contain a call to `git-update-server-info` but the `post-update` hook itself is disabled by default -- enable it -with `chmod +x post-update`. +with `chmod +x post-update`. This makes sure `git-update-server-info` +keeps the necessary files up-to-date. 3. Push into the public repository from your primary repository. @@ -1256,7 +1562,10 @@ on that project and has an own "public repository" goes like this: the "project lead" person does. 3. Copy over the packed files from "project lead" public - repository to your public repository. + repository to your public repository, unless the "project + lead" repository lives on the same machine as yours. In the + latter case, you can use `objects/info/alternates` file to + point at the repository you are borrowing from. 4. Push into the public repository from your primary repository. Run `git repack`, and possibly `git prune` if the @@ -1316,7 +1625,9 @@ cooperation you are probably more familiar with as well. For this, set up a public repository on a machine that is reachable via SSH by people with "commit privileges". Put the committers in the same user group and make the repository -writable by that group. +writable by that group. Make sure their umasks are set up to +allow group members to write into directories other members +have created. You, as an individual committer, then: @@ -1356,4 +1667,154 @@ fast forward. You need to pull and merge those other changes back before you push your work when it happens. +Advanced Shared Repository Management +------------------------------------- + +Being able to push into a shared repository means being able to +write into it. If your developers are coming over the network, +this means you, as the repository administrator, need to give +each of them an SSH access to the shared repository machine. + +In some cases, though, you may not want to give a normal shell +account to them, but want to restrict them to be able to only +do `git push` into the repository and nothing else. + +You can achieve this by setting the login shell of your +developers on the shared repository host to `git-shell` program. + +[NOTE] +Most likely you would also need to list `git-shell` program in +`/etc/shells` file. + +This restricts the set of commands that can be run from incoming +SSH connection for these users to only `receive-pack` and +`upload-pack`, so the only thing they can do are `git fetch` and +`git push`. + +You still need to create UNIX user accounts for each developer, +and put them in the same group. Make sure that the repository +shared among these developers is writable by that group. + +. Initializing the shared repository with `git-init-db --shared` +helps somewhat. + +. Run the following in the shared repository: ++ +------------ +$ chgrp -R $group repo.git +$ find repo.git -type d -print | xargs chmod ug+rwx,g+s +$ GIT_DIR=repo.git git repo-config core.sharedrepository true +------------ + +The above measures make sure that directories lazily created in +`$GIT_DIR` are writable by group members. You, as the +repository administrator, are still responsible to make sure +your developers belong to that shared repository group and set +their umask to a value no stricter than 027 (i.e. at least allow +reading and searching by group members). + +You can implement finer grained branch policies using update +hooks. There is a document ("control access to branches") in +Documentation/howto by Carl Baldwin and JC outlining how to (1) +limit access to branch per user, (2) forbid overwriting existing +tags. + + +Bundling your work together +--------------------------- + +It is likely that you will be working on more than one thing at +a time. It is easy to manage those more-or-less independent tasks +using branches with git. + +We have already seen how branches work previously, +with "fun and work" example using two branches. The idea is the +same if there are more than two branches. Let's say you started +out from "master" head, and have some new code in the "master" +branch, and two independent fixes in the "commit-fix" and +"diff-fix" branches: + +------------ +$ git show-branch +! [commit-fix] Fix commit message normalization. + ! [diff-fix] Fix rename detection. + * [master] Release candidate #1 +--- + + [diff-fix] Fix rename detection. + + [diff-fix~1] Better common substring algorithm. ++ [commit-fix] Fix commit message normalization. + + [master] Release candidate #1 ++++ [diff-fix~2] Pretty-print messages. +------------ + +Both fixes are tested well, and at this point, you want to merge +in both of them. You could merge in 'diff-fix' first and then +'commit-fix' next, like this: + +------------ +$ git merge 'Merge fix in diff-fix' master diff-fix +$ git merge 'Merge fix in commit-fix' master commit-fix +------------ + +Which would result in: + +------------ +$ git show-branch +! [commit-fix] Fix commit message normalization. + ! [diff-fix] Fix rename detection. + * [master] Merge fix in commit-fix +--- + + [master] Merge fix in commit-fix ++ + [commit-fix] Fix commit message normalization. + + [master~1] Merge fix in diff-fix + ++ [diff-fix] Fix rename detection. + ++ [diff-fix~1] Better common substring algorithm. + + [master~2] Release candidate #1 ++++ [master~3] Pretty-print messages. +------------ + +However, there is no particular reason to merge in one branch +first and the other next, when what you have are a set of truly +independent changes (if the order mattered, then they are not +independent by definition). You could instead merge those two +branches into the current branch at once. First let's undo what +we just did and start over. We would want to get the master +branch before these two merges by resetting it to 'master~2': + +------------ +$ git reset --hard master~2 +------------ + +You can make sure 'git show-branch' matches the state before +those two 'git merge' you just did. Then, instead of running +two 'git merge' commands in a row, you would pull these two +branch heads (this is known as 'making an Octopus'): + +------------ +$ git pull . commit-fix diff-fix +$ git show-branch +! [commit-fix] Fix commit message normalization. + ! [diff-fix] Fix rename detection. + * [master] Octopus merge of branches 'diff-fix' and 'commit-fix' +--- + + [master] Octopus merge of branches 'diff-fix' and 'commit-fix' ++ + [commit-fix] Fix commit message normalization. + ++ [diff-fix] Fix rename detection. + ++ [diff-fix~1] Better common substring algorithm. + + [master~1] Release candidate #1 ++++ [master~2] Pretty-print messages. +------------ + +Note that you should not do Octopus because you can. An octopus +is a valid thing to do and often makes it easier to view the +commit history if you are pulling more than two independent +changes at the same time. However, if you have merge conflicts +with any of the branches you are merging in and need to hand +resolve, that is an indication that the development happened in +those branches were not independent after all, and you should +merge two at a time, documenting how you resolved the conflicts, +and the reason why you preferred changes made in one side over +the other. Otherwise it would make the project history harder +to follow, not easier. + [ to be continued.. cvsimports ]