When showing only one branch a lot of default output becomes redundant,
so clean it up a bit, and document what is shown.  Retire the earlier
implementation "git-show-branches-script".
Signed-off-by: NJunio C Hamano <junkio@cox.net>

The 'git show-branches' command turns out to be reasonably useful,
but painfully slow.  So rewrite it in C, using ideas from merge-base
while enhancing it a bit more.

 - Unlike show-branches, it can take --heads (show me all my
   heads), --tags (show me all my tags), or --all (both).

 - It can take --more=<number> to show beyond the merge-base.

 - It shows the short name for each commit in the extended SHA1
   syntax.

 - It can find merge-base for more than two heads.

Examples:

    $ git show-branch --more=6 HEAD

    is almost the same as "git log --pretty=oneline --max-count=6".

    $ git show-branch --merge-base master mhf misc

    finds the merge base of the three given heads.

    $ git show-branch master mhf misc

    shows logs from the top of these three branch heads, up to their
    common ancestor commit is shown.

    $ git show-branch --all --more=10

    is poor-man's gitk, showing all the tags and heads, and
    going back 10 commits beyond the merge base of those refs.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

The new notation is a short-hand for <name> followed by <num>
caret ('^') characters.  E.g. "master~4" is the fourth
generation ancestor of the current "master" branch head,
following the first parents; same as "master^^^^" but a bit
more readable.

This will be used in the updated "git show-branch" command.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

When "git-diff-script A..B" notation was introduced, it ended up breaking
the traditional two revisions notation.

[jc: there are other issues with the current "git diff" I would like to
 address, but they would be left to later rounds.  For example, -M and -p flags
 should not be hardcoded default, and it shouldn't be too hard to rewrite
 the script without using shell arrays.]
Signed-off-by: NJunio C Hamano <junkio@cox.net>

This generalizes the git "glob" string to be a lot more like the
git-diff-* pathspecs (but there are still differences: the diff family
doesn't do any globbing, and because the diff family always generates the
full native pathname, it doesn't have the issue with "..").

It does three things:

 - it allows multiple matching strings, ie you can do things like

	git-ls-files arch/i386/ include/asm-i386/ | xargs grep pattern

 - the "matching" criteria is a combination of "exact path component
   match" (the same as the git-diff-* family), and "fnmatch()". However,
   you should be careful with the confusion between the git-ls-files
   internal globbing and the standard shell globbing, ie

	git-ls-files fs/*.c

   does globbing in the shell, and does something totally different from

	git-ls-files 'fs/*.c'

   which does the globbing inside git-ls-files.

   The latter has _one_ pathspec with a wildcard, and will match any .c
   file anywhere under the fs/ directory, while the former has been
   expanded by the shell into having _lots_ of pathspec entries, all of
   which are just in the top-level fs/ subdirectory. They will happily
   be matched exactly, but we will thus miss all the subdirectories under
   fs/.

   As a result, the first one will (on the current kernel) match 55 files,
   while the second one will match 664 files!

 - it uses the generic path prefixing, so that ".." and friends at the
   beginning of the path spec work automatically

   NOTE! When generating relative pathname output (the default), a
   pathspec that causes the base to be outside the current working
   directory will be rejected with an error message like:

	fatal: git-ls-files: cannot generate relative filenames containing '..'

   because we do not actually generate ".." in the output. However, the
   ".." format works fine for the --full-name case:

	cd arch/i386/kernel
	git-ls-files --full-name ../mm/

   results in

	arch/i386/mm/Makefile
	arch/i386/mm/boot_ioremap.c
	arch/i386/mm/discontig.c
	arch/i386/mm/extable.c
	arch/i386/mm/fault.c
	arch/i386/mm/highmem.c
	arch/i386/mm/hugetlbpage.c
	arch/i386/mm/init.c
	arch/i386/mm/ioremap.c
	arch/i386/mm/mmap.c
	arch/i386/mm/pageattr.c
	arch/i386/mm/pgtable.c

   Perhaps more commonly, the generic path prefixing means that "." and
   "./" automatically get simplified and work properly.
Signed-off-by: NLinus Torvalds <torvalds@osdl.org>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

This makes git-ls-files work inside a relative directory, and also adds
some rudimentary filename globbing support. For example, in the kernel you
can now do

	cd arch/i386
	git-ls-files

and it will show all files under that subdirectory (and it will have
removed the "arch/i386/" prefix unless you give it the "--full-name"
option, so that you can feed the result to "xargs grep" or similar).

The filename globbing is kind of strange: it does _not_ follow normal
globbing rules, although it does look "almost" like a normal file glob
(and it uses the POSIX.2 "fnmatch()" function).

The glob pattern (there can be only one) is always split into a "directory
part" and a "glob part", where the directory part is defined as any full
directory path without any '*' or '?' characters. The "glob" part is
whatever is left over.

For example, when doing

	git-ls-files 'arch/i386/p*/*.c'

the "directory part" is is "arch/i386/", and the "glob part" is "p*/*.c".
The directory part will be added to the prefix, and handled efficiently
(ie we will not be searching outside of that subdirectory), while the glob
part (if anything is left over) will be used to trigger "fnmatch()"
matches.

This is efficient and very useful, but can result in somewhat
non-intuitive behaviour.

For example:

	git-ls-files 'arch/i386/*.[ch]'

will find all .c and .h files under arch/i386/, _including_ things in
lower subdirectories (ie it will match "arch/i386/kernel/process.c",
because "kernel/process.c" will match the "*.c" specifier).

Also, while

	git-ls-files arch/i386/

will show all files under that subdirectory, doing the same without the
final slash would try to show the file "i386" under the "arch/"
subdirectory, and since there is no such file (even if there is such a
_directory_) it will not match anything at all.

These semantics may not seem intuitive, but they are actually very
practical. In particular, it makes it very simple to do

	git-ls-files fs/*.c | xargs grep some_pattern

and it does what you want.
Signed-off-by: NLinus Torvalds <torvalds@osdl.org>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

I think Linus did a cut & paste from an early JIT code while
developing the current extended SHA1 notation, and left it there as a
courtesy, but the directory does not deserve to be treated any more
specially than, say, .git/refs/bisect.

If the subdirectories under .git/refs proliferate, we may want to
switch to scanning that hierarchy at runtime, instead of the current
hard-coded set, although I think that would be overkill.
Signed-off-by: NJunio C Hamano <junkio@cox.net>
From nobody Mon Sep 17 00:00:00 2001
Subject: [PATCH] Add a new extended SHA1 syntax <name>:<num>
From: Junio C Hamano <junkio@cox.net>
Date: 1124617434 -0700

The new notation is a short-hand for <name> followed by <num>
caret ('^') characters.  E.g. "master:4" is the fourth
generation ancestor of the current "master" branch head,
following the first parents; same as "master^^^^" but a bit more
readable.

This will be used in the updated "git show-branch" command.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

---

 sha1_name.c |   41 +++++++++++++++++++++++++++++++++++++++++
 1 files changed, 41 insertions(+), 0 deletions(-)

d5098ce769da46df6d45dc8f41b06dd758fdaea7
diff --git a/sha1_name.c b/sha1_name.c
--- a/sha1_name.c
+++ b/sha1_name.c
@@ -191,9 +191,29 @@ static int get_parent(const char *name, 
 	return -1;
 }
 
+static int get_nth_ancestor(const char *name, int len,
+			    unsigned char *result, int generation)
+{
+	unsigned char sha1[20];
+	int ret = get_sha1_1(name, len, sha1);
+	if (ret)
+		return ret;
+
+	while (generation--) {
+		struct commit *commit = lookup_commit_reference(sha1);
+
+		if (!commit || parse_commit(commit) || !commit->parents)
+			return -1;
+		memcpy(sha1, commit->parents->item->object.sha1, 20);
+	}
+	memcpy(result, sha1, 20);
+	return 0;
+}
+
 static int get_sha1_1(const char *name, int len, unsigned char *sha1)
 {
 	int parent, ret;
+	const char *cp;
 
 	/* foo^[0-9] or foo^ (== foo^1); we do not do more than 9 parents. */
 	if (len > 2 && name[len-2] == '^' &&
@@ -210,6 +230,27 @@ static int get_sha1_1(const char *name, 
 	if (parent >= 0)
 		return get_parent(name, len, sha1, parent);
 
+	/* name:3 is name^^^,
+	 * name:12 is name^^^^^^^^^^^^, and
+	 * name: is name
+	 */
+	parent = 0;
+	for (cp = name + len - 1; name <= cp; cp--) {
+		int ch = *cp;
+		if ('0' <= ch && ch <= '9')
+			continue;
+		if (ch != ':')
+			parent = -1;
+		break;
+	}
+	if (!parent && *cp == ':') {
+		int len1 = cp - name;
+		cp++;
+		while (cp < name + len)
+			parent = parent * 10 + *cp++ - '0';
+		return get_nth_ancestor(name, len1, sha1, parent);
+	}
+
 	ret = get_sha1_basic(name, len, sha1);
 	if (!ret)
 		return 0;

Here is a patch to fix the problem in the simplest way.

Signed-off-by: NJunio C Hamano <junkio@cox.net>

When git-commit-script is called with -v option and
verify test fails result is print on stdout
instead of stderr.

[jc: The original patch from Marco updated git-commit-script that
still had the piece of code in question, which has been moved to
an example hook script on its own, so I transplanted the patch to
that new file instead.]
Signed-off-by: NMarco Costalba <mcostalba@yahoo.it>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

Recent change to make sure we get commit, not tag, accidentally
removed its feature of giving a usage help message when it died.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

Use the common error message format, "filename:lineno: body";
this way, problematic lines can be jumped to from the Emacs
compilation buffer by C-x `.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

Add -n (dryrun) flag to git-prune-packed, and call it from "git prune".
Signed-off-by: NJunio C Hamano <junkio@cox.net>

This teachs git-applypatch, which is used from git-applymbox, three
hooks, similar to what git-commit-script uses.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

There are three hooks:

    - 'pre-commit' is given an opportunity to inspect what is
      being committed, before we invoke the EDITOR for the
      commit message;

    - 'commit-msg' is invoked on the commit log message after
      the user prepares it;

    - 'post-commit' is run after a successful commit is made.

The first two can interfere to stop the commit.  The last one is
for after-the-fact notification.

The earlier built-in commit checker is now moved to pre-commit.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

After you deleted files from your working tree, automatic
git-update-cache used when the "--all" flag is given to "git
commit" barfs because it lacks the --remove flag.

It can be argued that this is a feature; people should be
careful and something with a grave consequence like removing
files should be done manually, in which case the current
behaviour may be OK.

The patch is for people who thinks the user who uses the "--all"
flag deserves the danger that comes with the convenience.

Comments?
Signed-off-by: NJunio C Hamano <junkio@cox.net>

When following tags, check for parse_object() success and error out
properly instead of segfaulting.
Signed-off-by: NSergey Vlasov <vsu@altlinux.ru>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

In case of a commit with an empty message there is no
mandatory empty line between headers and body

[jc: This makes --mbox output valid even when the commit message does
not have anything but its first line, which the one I wrote botched.
One side-effect is that it adds an extra blank line at the end even if
it has more than one lines, which will be eaten by the receiving end.
As Marco says, this is a stop-gap measure.  This script needs to be
split into two, one that gets the format specifier and a commit ID to
write to its standard output, and another that drives that one reading
from rev-list.  I'll fix things properly when that happens by
rewriting the former part in Perl or something more reasonable than
the current shell, sed and grep mishmash.]
Signed-off-by: NMarco Costalba <mcostalba@yahoo.it>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

This just displays the result of git-cat-file on the tag in the
details pane.  If the tag is a "direct" tag (the tag file contains
the SHA1 ID of a commit rather than a tag), we show the tag name
and SHA1 ID.

These are features requested by Junio.  Any plain file under .git/refs
whose contents start with 40 hex characters is taken as a reference
and displayed like a head but with a light blue background (unless it
is in .git/refs/tags or .git/refs/heads, in which case it is displayed
as before).  There is now a "Reread references" menu item in the File
menu which re-reads all the plain files under .git/refs and redisplays
any references that have changed.

It cannot be checked with #ifndef, if you really think about what it
does which cannot be done only with the preprocessor.  My thinko.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

Sun's cc doesn't know __attribute__.
Signed-off-by: NJason Riedy <ejr@cs.berkeley.edu>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

This problem was revealed by running gitk --all on Wolfgang Denk's
u-boot repository.

Otherwise the first commit rebase makes could include whatever
dirty state the original working tree had.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

This makes git-applymbox verify that the index matches the current HEAD
before it starts applying patches.

Otherwise, you might have updated the index with unrelated changes, and
the first patch will commit not just the patch from the mbox, but also any
changes you had in your index.
Signed-off-by: NLinus Torvalds <torvalds@osdl.org>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

Signed-off-by: NJunio C Hamano <junkio@cox.net>

Signed-off-by: NJunio C Hamano <junkio@cox.net>

Changes to the descriptions of tree and tag objects, a link for ent, and
descriptions for rewind, rebase and core git were added.
Signed-off-by: NJohannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

Small fix (use "git branch" to make branches, rather than "git checkout -b").

Optimization for trivial patches (apply to release and merge to test).

Three sample scripts appended.
Signed-off-by: NTony Luck <tony.luck@intel.com>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

This also includes a script which does the sorting, and introduces
hyperlinks for every described term.
Signed-off-by: NJohannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

With --parents, git-rev-list gives us the list of parents on the
first line of each commit.  We use that rather than looking for
the parent: lines in the commit body, since this way we get to
know about the grafts for free.

Based on the discussion on the git list, here are some important changes
to the glossary. (There is no cache, but an index. Use "object name"
rather than "SHA1". Reorder. Clarify.)
Signed-off-by: NJohannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: NJunio C Hamano <junkio@cox.net>

When the graph gets too wide (as defined by the maxwidth variable,
which can be set in ~/.gitk), we can now terminate graph lines with
an arrow pointing downwards, and reintroduce them later with an
arrow pointing upwards when we need them.  This makes the graph much
less cluttered on large repositories such as the linux kernel.

Unfortunately this has made it slower; it takes about 10 seconds
user time on the linux-2.6 repository on my machine now, compared
to 6 seconds before.  I'll have to work on optimizing that.  Also
on the todo list are making the arrow heads active (so if you click
on them you jump to the other end) and improving the placement of
the null entry.

It did not check to see if the working tree was clean and matched
the commit we were starting out as, resulting in the initial rebased
commit including whatever dirty state the working tree has had.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

When we create a cheap local clone by pointing at the object databse
of the original repository, we forgot to take the alternates the original
repository might have had into account.
Signed-off-by: NJunio C Hamano <junkio@cox.net>

The earlier one to grab output from diff-files --name-only has a grave
bug that when no paths are given it ended up doing the equivalent of
"git-commit --all", which was not what I intended.
Signed-off-by: NJunio C Hamano <junkio@cox.net>