GIT 0.99.9f
Signed-off-by: Junio C Hamano <junkio@cox.net>
diff --git a/Documentation/Makefile b/Documentation/Makefile
index f45a062..be4f3e1 100644
--- a/Documentation/Makefile
+++ b/Documentation/Makefile
@@ -53,8 +53,7 @@
#
# Determine "include::" file references in asciidoc files.
#
-TEXTFILES = $(wildcard git-*.txt)
-doc.dep : $(TEXTFILES) build-docdep.perl
+doc.dep : $(wildcard *.txt) build-docdep.perl
rm -f $@+ $@
perl ./build-docdep.perl >$@+
mv $@+ $@
diff --git a/Documentation/build-docdep.perl b/Documentation/build-docdep.perl
index dedef76..6ff35e0 100755
--- a/Documentation/build-docdep.perl
+++ b/Documentation/build-docdep.perl
@@ -1,28 +1,54 @@
#!/usr/bin/perl
my %include = ();
+my %included = ();
-for my $text (<git-*.txt>) {
+for my $text (<*.txt>) {
open I, '<', $text || die "cannot read: $text";
- (my $base = $text) =~ s/\.txt$//;
while (<I>) {
if (/^include::/) {
chomp;
s/^include::\s*//;
s/\[\]//;
- $include{$base}{$_} = 1;
+ $include{$text}{$_} = 1;
+ $included{$_} = 1;
}
}
close I;
}
# Do we care about chained includes???
-
-while (my ($base, $included) = each %include) {
- my ($suffix) = '1';
- if ($base eq 'git') {
- $suffix = '7'; # yuck...
+my $changed = 1;
+while ($changed) {
+ $changed = 0;
+ while (my ($text, $included) = each %include) {
+ print STDERR "Looking at $text...\n";
+ for my $i (keys %$included) {
+ print STDERR "$text includes $i.\n";
+ # $text has include::$i; if $i includes $j
+ # $text indirectly includes $j.
+ if (exists $include{$i}) {
+ print STDERR "$i includes something.\n";
+ for my $j (keys %{$include{$i}}) {
+ print STDERR "$text includes $i include $j\n";
+ if (!exists $include{$text}{$j}) {
+ $include{$text}{$j} = 1;
+ $included{$j} = 1;
+ $changed = 1;
+ }
+ }
+ }
+ }
}
- print "$base.html $base.$suffix : ", join(" ", keys %$included), "\n";
}
+while (my ($text, $included) = each %include) {
+ if (! exists $included{$text} &&
+ (my $base = $text) =~ s/\.txt$//) {
+ my ($suffix) = '1';
+ if ($base eq 'git') {
+ $suffix = '7'; # yuck...
+ }
+ print "$base.html $base.$suffix : ", join(" ", keys %$included), "\n";
+ }
+}
diff --git a/Documentation/fetch-options.txt b/Documentation/fetch-options.txt
index 12d12b2..0e502ae 100644
--- a/Documentation/fetch-options.txt
+++ b/Documentation/fetch-options.txt
@@ -6,6 +6,9 @@
-f, \--force::
-t, \--tags::
+ By default, the git core utilities will not fetch and store
+ tags under the same name as the remote repository; ask it
+ to do so using `--tags`.
-u, \--update-head-ok::
By default `git-fetch` refuses to update the head which
diff --git a/Documentation/howto/isolate-bugs-with-bisect.txt b/Documentation/howto/isolate-bugs-with-bisect.txt
new file mode 100644
index 0000000..4009495
--- /dev/null
+++ b/Documentation/howto/isolate-bugs-with-bisect.txt
@@ -0,0 +1,65 @@
+From: Linus Torvalds <torvalds () osdl ! org>
+To: git@vger.kernel.org
+Date: 2005-11-08 1:31:34
+Subject: Real-life kernel debugging scenario
+Abstract: Short-n-sweet, Linus tells us how to leverage `git-bisect` to perform
+ bug isolation on a repository where "good" and "bad" revisions are known
+ in order to identify a suspect commit.
+
+
+How To Use git-bisect To Isolate a Bogus Commit
+===============================================
+
+The way to use "git bisect" couldn't be easier.
+
+Figure out what the oldest bad state you know about is (that's usually the
+head of "master", since that's what you just tried to boot and failed at).
+Also, figure out the most recent known-good commit (usually the _previous_
+kernel you ran: and if you've only done a single "pull" in between, it
+will be ORIG_HEAD).
+
+Then do
+
+ git bisect start
+ git bisect bad master <- mark "master" as the bad state
+ git bisect good ORIG_HEAD <- mark ORIG_HEAD as good (or
+ whatever other known-good
+ thing you booted laste)
+
+and at this point "git bisect" will churn for a while, and tell you what
+the mid-point between those two commits are, and check that state out as
+the head of the bew "bisect" branch.
+
+Compile and reboot.
+
+If it's good, just do
+
+ git bisect good <- mark current head as good
+
+otherwise, reboot into a good kernel instead, and do (surprise surprise,
+git really is very intuitive):
+
+ git bisect bad <- mark current head as bad
+
+and whatever you do, git will select a new half-way point. Do this for a
+while, until git tells you exactly which commit was the first bad commit.
+That's your culprit.
+
+It really works wonderfully well, except for the case where there was
+_another_ commit that broke something in between, like introduced some
+stupid compile error. In that case you should not mark that commit good or
+bad: you should try to find another commit close-by, and do a "git reset
+--hard <newcommit>" to try out _that_ commit instead, and then test that
+instead (and mark it good or bad).
+
+You can do "git bisect visualize" while you do all this to see what's
+going on by starting up gitk on the bisection range.
+
+Finally, once you've figured out exactly which commit was bad, you can
+then go back to the master branch, and try reverting just that commit:
+
+ git checkout master
+ git revert <bad-commit-id>
+
+to verify that the top-of-kernel works with that single commit reverted.
+
diff --git a/Documentation/tutorial.txt b/Documentation/tutorial.txt
index 6d2c153..95ed852 100644
--- a/Documentation/tutorial.txt
+++ b/Documentation/tutorial.txt
@@ -36,14 +36,16 @@
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
@@ -114,8 +116,8 @@
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
@@ -137,7 +139,7 @@
So to populate the index with the two files you just created, you can do
------------------------------------------------
-git-update-index --add hello example
+$ git-update-index --add hello example
------------------------------------------------
and you have now told git to track those two files.
@@ -146,12 +148,17 @@
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.
@@ -159,13 +166,17 @@
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
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`.
@@ -202,7 +213,7 @@
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
@@ -210,7 +221,7 @@
`git-diff-files` command:
------------
-git-diff-files
+$ git-diff-files
------------
Oops. That wasn't very readable. It just spit out its own internal
@@ -222,12 +233,7 @@
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
@@ -264,13 +270,15 @@
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
@@ -299,14 +307,16 @@
all with a sequence of simple shell commands:
------------------------------------------------
-tree=$(git-write-tree)
-commit=$(echo 'Initial commit' | git-commit-tree $tree)
-git-update-ref HEAD $commit
+$ 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*
@@ -349,7 +359,9 @@
But now we can do
- git-diff-index -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.
@@ -360,7 +372,9 @@
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.
@@ -396,7 +410,7 @@
update the index cache:
------------------------------------------------
-git-update-index hello
+$ git-update-index hello
------------------------------------------------
(note how we didn't need the `\--add` flag this time, since git knew
@@ -417,7 +431,7 @@
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
@@ -450,7 +464,9 @@
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.
@@ -505,13 +521,17 @@
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.
@@ -547,14 +567,16 @@
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
@@ -568,7 +590,9 @@
that tag. You create these annotated tags with either the `-a` or
`-s` flag to `git tag`:
- git tag -s <tagname>
+----------------
+$ git tag -s <tagname>
+----------------
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
@@ -584,8 +608,8 @@
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.
@@ -602,8 +626,10 @@
- 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.
@@ -618,8 +644,10 @@
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-index --refresh
++
+----------------
+$ git-update-index --refresh
+----------------
+
in the new repository to make sure that the index file is up-to-date.
@@ -633,8 +661,10 @@
known state (you don't know *what* they've done and not yet checked in),
so usually you'll precede the `git-update-index` with a
- git-read-tree --reset HEAD
- git-update-index --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-index`
@@ -645,7 +675,9 @@
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. You can learn things by just looking
@@ -665,20 +697,26 @@
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-index -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
@@ -689,9 +727,11 @@
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.
@@ -719,7 +759,7 @@
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
@@ -733,7 +773,7 @@
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,
@@ -743,27 +783,27 @@
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
+$ cat .git/HEAD
------------
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`.
@@ -773,7 +813,7 @@
checking it out and switching to it. If so, just use the command
------------
-git branch <branchname> [startingpoint]
+$ git branch <branchname> [startingpoint]
------------
which will simply _create_ the branch, but will not do anything further.
@@ -792,9 +832,9 @@
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
@@ -807,7 +847,7 @@
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
@@ -815,9 +855,9 @@
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.
@@ -826,7 +866,9 @@
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
@@ -840,7 +882,7 @@
to resolve and what the merge is all about:
------------
-git merge "Merge work in mybranch" HEAD mybranch
+$ git merge "Merge work in mybranch" HEAD mybranch
------------
where the first argument is going to be used as the commit message if
@@ -851,6 +893,7 @@
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:
+----------------
Trying really trivial in-index merge...
fatal: Merge requires file-level merging
Nope.
@@ -859,6 +902,7 @@
ERROR: Merge conflict in hello.
fatal: merge program failed
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"
@@ -879,7 +923,7 @@
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
@@ -929,17 +973,19 @@
resolve to get the "upstream changes" back to your branch.
------------
-git checkout mybranch
-git merge "Merge upstream changes." HEAD master
+$ 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
@@ -965,14 +1011,16 @@
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 <remote-repository>
+----------------
+$ git fetch <remote-repository>
+----------------
One of the following transports can be used to name the
repository to download from:
@@ -1017,7 +1065,7 @@
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
@@ -1047,7 +1095,9 @@
immediately `resolve`, that it's called `git pull`, and you can
simply do
- git pull <remote-repository>
+----------------
+$ git pull <remote-repository>
+----------------
and optionally give a branch-name for the remote end as a second
argument.
@@ -1075,8 +1125,8 @@
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
------------------------------------------------
@@ -1086,7 +1136,7 @@
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
------------------------------------------------
@@ -1206,7 +1256,8 @@
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 the real changes in non-zero stages.
+fairly quickly, leaving only a handful the real changes in non-zero
+stages.
To look at only non-zero stages, use `\--unmerged` flag:
@@ -1299,7 +1350,7 @@
an empty directory:
------------
-mkdir my-git.git
+$ mkdir my-git.git
------------
Then, make that directory into a git repository by running
@@ -1307,7 +1358,7 @@
`.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
@@ -1333,7 +1384,7 @@
there, run this command:
------------
-git push <public-host>:/path/to/my-git.git master
+$ git push <public-host>:/path/to/my-git.git master
------------
This synchronizes your public repository to match the named
@@ -1345,7 +1396,7 @@
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/
------------
@@ -1360,7 +1411,7 @@
storage by "packing them together". The command
------------
-git repack
+$ git repack
------------
will do it for you. If you followed the tutorial examples, you
@@ -1386,7 +1437,7 @@
unpacked objects that are contained in the pack file anymore.
------------
-git prune-packed
+$ git prune-packed
------------
would remove them for you.
@@ -1615,8 +1666,8 @@
'commit-fix' next, like this:
------------
-$ git resolve master diff-fix 'Merge fix in diff-fix'
-$ git resolve master commit-fix 'Merge fix in commit-fix'
+$ git merge 'Merge fix in diff-fix' master diff-fix
+$ git merge 'Merge fix in commit-fix' master commit-fix
------------
Which would result in:
@@ -1649,8 +1700,8 @@
------------
You can make sure 'git show-branch' matches the state before
-those two 'git resolve' you just did. Then, instead of running
-two 'git resolve' commands in a row, you would pull these two
+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'):
------------
diff --git a/Makefile b/Makefile
index ba1c6a7..bfdaf76 100644
--- a/Makefile
+++ b/Makefile
@@ -50,9 +50,10 @@
# Define USE_STDEV below if you want git to care about the underlying device
# change being considered an inode change from the update-cache perspective.
-GIT_VERSION = 0.99.9e
+GIT_VERSION = 0.99.9f
# CFLAGS is for the users to override from the command line.
+
CFLAGS = -g -O2 -Wall
ALL_CFLAGS = $(CFLAGS)
diff --git a/debian/changelog b/debian/changelog
index 9cf900f..03a0f79 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+git-core (0.99.9f-0) unstable; urgency=low
+
+ * GIT 0.99.9f
+
+ -- Junio C Hamano <junkio@cox.net> Tue, 8 Nov 2005 01:21:52 -0800
+
git-core (0.99.9e-0) unstable; urgency=low
* GIT 0.99.9e
@@ -28,6 +34,14 @@
-- Junio C Hamano <junkio@cox.net> Sun, 30 Oct 2005 15:03:32 -0800
+git-core (0.99.9.GIT-1) unstable; urgency=low
+
+ * Do not scatter txt and html documentation into feature
+ subpackages. Do place man pages into them.
+ * Capture more cvs stuff into git-cvs package.
+
+ -- Junio C Hamano <junkio@cox.net> Tue, 8 Nov 2005 01:19:06 -0800
+
git-core (0.99.9.GIT-0) unstable; urgency=low
* Test Build.
diff --git a/debian/git-arch.files b/debian/git-arch.files
index 1ad4656..d744954 100644
--- a/debian/git-arch.files
+++ b/debian/git-arch.files
@@ -1,2 +1,2 @@
-/usr/bin/git-archimport
-/usr/share/doc/git-core/git-archimport.*
+/usr/bin/git-arch*
+/usr/share/man/*/git-arch*
diff --git a/debian/git-core.doc-base b/debian/git-core.doc-base
index 1ed4633..eff1a95 100644
--- a/debian/git-core.doc-base
+++ b/debian/git-core.doc-base
@@ -6,6 +6,8 @@
Format: HTML
Index: /usr/share/doc/git-core/git.html
Files: /usr/share/doc/git-core/*.html
+ /usr/share/doc/git-core/*/*.html
Format: text
-Files: /usr/share/doc/git-core/git.txt*
+Files: /usr/share/doc/git-core/*.txt
+ /usr/share/doc/git-core/*/*.txt
diff --git a/debian/git-cvs.files b/debian/git-cvs.files
index 8bf5090..a6b40ff 100644
--- a/debian/git-cvs.files
+++ b/debian/git-cvs.files
@@ -1,2 +1,2 @@
-/usr/bin/git-cvsimport
-/usr/share/doc/git-core/git-cvsimport.*
+/usr/bin/git-cvs*
+/usr/share/man/*/git-cvs*
diff --git a/debian/git-doc.files b/debian/git-doc.files
index 567f5d7..0daf545 100644
--- a/debian/git-doc.files
+++ b/debian/git-doc.files
@@ -2,6 +2,3 @@
/usr/share/doc/git-core/*.html
/usr/share/doc/git-core/*/*.html
/usr/share/doc/git-core/*/*.txt
-
-
-
diff --git a/debian/git-email.files b/debian/git-email.files
index 236754c..2d6a51f 100644
--- a/debian/git-email.files
+++ b/debian/git-email.files
@@ -1,2 +1,2 @@
/usr/bin/git-send-email
-/usr/share/doc/git-core/git-send-email.*
+/usr/share/man/*/git-send-email.*
diff --git a/debian/git-svn.files b/debian/git-svn.files
index 317b12a..eea8d83 100644
--- a/debian/git-svn.files
+++ b/debian/git-svn.files
@@ -1,2 +1,2 @@
-/usr/bin/git-svnimport
-/usr/share/doc/git-core/git-svnimport.*
+/usr/bin/git-svn*
+/usr/share/man/*/git-svn*
diff --git a/debian/git-tk.files b/debian/git-tk.files
index e54f897..478ec94 100644
--- a/debian/git-tk.files
+++ b/debian/git-tk.files
@@ -1,3 +1,2 @@
/usr/bin/gitk
/usr/share/man/man1/gitk.*
-/usr/share/doc/git-core/gitk.*
diff --git a/git-am.sh b/git-am.sh
index 115ebad..38841d9 100755
--- a/git-am.sh
+++ b/git-am.sh
@@ -224,29 +224,33 @@
git-stripspace < "$dotest/msg" > "$dotest/msg-clean"
;;
esac
- resume=
GIT_AUTHOR_NAME="$(sed -n '/^Author/ s/Author: //p' "$dotest/info")"
GIT_AUTHOR_EMAIL="$(sed -n '/^Email/ s/Email: //p' "$dotest/info")"
GIT_AUTHOR_DATE="$(sed -n '/^Date/ s/Date: //p' "$dotest/info")"
- SUBJECT="$(sed -n '/^Subject/ s/Subject: //p' "$dotest/info")"
export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE
+ SUBJECT="$(sed -n '/^Subject/ s/Subject: //p' "$dotest/info")"
case "$keep_subject" in -k) SUBJECT="[PATCH] $SUBJECT" ;; esac
- if test '' != "$SIGNOFF"
- then
+
+ case "$resume" in
+ '')
+ if test '' != "$SIGNOFF"
+ then
LAST_SIGNED_OFF_BY=`
- sed -ne '/^Signed-off-by: /p' "$dotest/msg-clean" |
- tail -n 1
+ sed -ne '/^Signed-off-by: /p' \
+ "$dotest/msg-clean" |
+ tail -n 1
`
- ADD_SIGNOFF=$(test "$LAST_SIGNED_OFF_BY" = "$SIGNOFF" || {
+ ADD_SIGNOFF=`
+ test "$LAST_SIGNED_OFF_BY" = "$SIGNOFF" || {
test '' = "$LAST_SIGNED_OFF_BY" && echo
echo "$SIGNOFF"
- })
- else
+ }`
+ else
ADD_SIGNOFF=
- fi
- {
+ fi
+ {
echo "$SUBJECT"
if test -s "$dotest/msg-clean"
then
@@ -257,8 +261,11 @@
then
echo "$ADD_SIGNOFF"
fi
- } >"$dotest/final-commit"
+ } >"$dotest/final-commit"
+ ;;
+ esac
+ resume=
if test "$interactive" = t
then
test -t 0 ||
diff --git a/git-push.sh b/git-push.sh
index 5aa6531..edc0b83 100755
--- a/git-push.sh
+++ b/git-push.sh
@@ -46,7 +46,7 @@
shift
case "$remote" in
-http://* | https://* | git://*)
+git://*)
die "Cannot use READ-ONLY transport to push to $remote" ;;
rsync://*)
die "Pushing with rsync transport is deprecated" ;;
@@ -57,4 +57,9 @@
test "$has_force" && set x "$has_force" "$@" && shift
test "$has_exec" && set x "$has_exec" "$@" && shift
-exec git-send-pack "$@"
+case "$remote" in
+http://* | https://*)
+ exec git-http-push "$@";;
+*)
+ exec git-send-pack "$@";;
+esac
diff --git a/ls-files.c b/ls-files.c
index f7653e7..db2288a 100644
--- a/ls-files.c
+++ b/ls-files.c
@@ -570,6 +570,7 @@
prefix = setup_git_directory();
if (prefix)
prefix_offset = strlen(prefix);
+ git_config(git_default_config);
for (i = 1; i < argc; i++) {
const char *arg = argv[i];
diff --git a/read-tree.c b/read-tree.c
index 6a456ae..df156ea 100644
--- a/read-tree.c
+++ b/read-tree.c
@@ -633,6 +633,8 @@
if (newfd < 0)
die("unable to create new cachefile");
+ git_config(git_default_config);
+
merge = 0;
reset = 0;
for (i = 1; i < argc; i++) {
