Retire rev-tree.

Some old scripts might still use git-rev-tree, but it really is
clearly inferior in every way to git-rev-list that such scripts should
be fixed anyway. Fixing them should be pretty easy.

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

diff --git a/.gitignore b/.gitignore
index 007b540f4e825830275fcea889652f2917d7e5be..0a876865c0b4f7a9908375134ace0dd43f4cd568 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -69,7 +69,6 @@ git-reset
 git-resolve
 git-rev-list
 git-rev-parse
-git-rev-tree
 git-revert
 git-send-email
 git-send-pack

diff --git a/Documentation/git-rev-tree.txt b/Documentation/git-rev-tree.txt
deleted file mode 100644 (file)
index aa98f64..0000000
--- a/Documentation/git-rev-tree.txt
+++ /dev/null
@@ -1,88 +0,0 @@
-git-rev-tree(1)
-===============
-v0.1, May 2005
-
-NAME
-----
-git-rev-tree - Provides the revision tree for one or more commits
-
-
-SYNOPSIS
---------
-'git-rev-tree' [--edges] [--cache <cache-file>] [^]<commit> [[^]<commit>]
-
-DESCRIPTION
------------
-Provides the revision tree for one or more commits.
-
-OPTIONS
--------
---edges::
-       Show edges (ie places where the marking changes between parent
-       and child)
-
---cache <cache-file>::
-       Use the specified file as a cache from a previous git-rev-list run
-       to speed things up.  Note that this "cache" is totally different
-       concept from the directory index.  Also this option is not
-       implemented yet.
-
-[^]<commit>::
-       The commit id to trace (a leading caret means to ignore this
-       commit-id and below)
-
-Output
-------
-
-        <date> <commit>:<flags> [<parent-commit>:<flags> ]\*
-
-<date>::
-       Date in 'seconds since epoch'
-
-<commit>::
-       id of commit object
-
-<parent-commit>::
-       id of each parent commit object (>1 indicates a merge)
-
-<flags>::
-
-       The flags are read as a bitmask representing each commit
-       provided on the commandline. eg: given the command:
-
-                $ git-rev-tree <com1> <com2> <com3>
-
-       The output:
-
-           <date> <commit>:5
-
-        means that <commit> is reachable from <com1>(1) and <com3>(4)
-       
-A revtree can get quite large. "git-rev-tree" will eventually allow
-you to cache previous state so that you don't have to follow the whole
-thing down.
-
-So the change difference between two commits is literally
-
-       git-rev-tree [commit-id1]  > commit1-revtree
-       git-rev-tree [commit-id2]  > commit2-revtree
-       join -t : commit1-revtree commit2-revtree > common-revisions
-
-(this is also how to find the most common parent - you'd look at just
-the head revisions - the ones that aren't referred to by other
-revisions - in "common-revision", and figure out the best one. I
-think.)
-
-
-Author
-------
-Written by Linus Torvalds <torvalds@osdl.org>
-
-Documentation
---------------
-Documentation by David Greaves, Junio C Hamano and the git-list <git@vger.kernel.org>.
-
-GIT
----
-Part of the gitlink:git[7] suite
-

diff --git a/Documentation/git.txt b/Documentation/git.txt
index e9158895b1d08c19aeb2abf6fb191c6da0eba6e4..2684fa9393cdc7859e91c01ea6a42bfa92a58143 100644 (file)
--- a/Documentation/git.txt
+++ b/Documentation/git.txt
@@ -134,9 +134,6 @@ gitlink:git-merge-base[1]::
 gitlink:git-rev-list[1]::
        Lists commit objects in reverse chronological order
 
-gitlink:git-rev-tree[1]::
-       Provides the revision tree for one or more commits
-
 gitlink:git-show-index[1]::
        Displays contents of a pack idx file.
 

diff --git a/Documentation/howto/using-topic-branches.txt b/Documentation/howto/using-topic-branches.txt
index b3b4d2c97aa4ccdffc3772ef4e745e14d323a995..d30fa850480446a6682430db2a327986e6f65e69 100644 (file)
--- a/Documentation/howto/using-topic-branches.txt
+++ b/Documentation/howto/using-topic-branches.txt
@@ -245,7 +245,7 @@ gb=$(tput setab 2)
 rb=$(tput setab 1)
 restore=$(tput setab 9)
 
-if [ `git-rev-tree release ^test | wc -c` -gt 0 ]
+if [ `git-rev-list release ^test | wc -c` -gt 0 ]
 then
        echo $rb Warning: commits in release that are not in test $restore
        git-whatchanged release ^test
@@ -262,7 +262,7 @@ do
        status=
        for ref in test release linus
        do
-               if [ `git-rev-tree $branch ^$ref | wc -c` -gt 0 ]
+               if [ `git-rev-list $branch ^$ref | wc -c` -gt 0 ]
                then
                        status=$status${ref:0:1}
                fi

diff --git a/Makefile b/Makefile
index 7559e1451bc22ec19de08675122c204e0c0c4c6f..1b805b0047ab4849e687925238717c951691b297 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -109,7 +109,7 @@ PROGRAMS = \
        git-merge-index git-mktag git-pack-objects git-patch-id \
        git-peek-remote git-prune-packed git-read-tree \
        git-receive-pack git-rev-list git-rev-parse \
-       git-rev-tree git-send-pack git-show-branch \
+       git-send-pack git-show-branch \
        git-show-index git-ssh-fetch \
        git-ssh-upload git-tar-tree git-unpack-file \
        git-unpack-objects git-update-index git-update-server-info \

diff --git a/rev-tree.c b/rev-tree.c
deleted file mode 100644 (file)
index 7f92819..0000000
--- a/rev-tree.c
+++ /dev/null
@@ -1,140 +0,0 @@
-#include "cache.h"
-#include "commit.h"
-
-/*
- * revision.h leaves the low 16 bits of the "flags" field of the
- * revision data structure unused. We use it for a "reachable from
- * this commit <N>" bitmask.
- */
-#define MAX_COMMITS 16
-#define REACHABLE (1U << 16)
-
-#define cmit_flags(cmit) ((cmit)->object.flags & ~REACHABLE)
-
-static int show_edges = 0;
-static int basemask = 0;
-
-static void read_cache_file(const char *path)
-{
-       die("no revtree cache file yet");
-}
-
-/*
- * Some revisions are less interesting than others.
- *
- * For example, if we use a cache-file, that one may contain
- * revisions that were never used. They are never interesting.
- *
- * And sometimes we're only interested in "edge" commits, ie
- * places where the marking changes between parent and child.
- */
-static int interesting(struct commit *rev)
-{
-       unsigned mask = cmit_flags(rev);
-
-       if (!mask)
-               return 0;
-       if (show_edges) {
-               struct commit_list *p = rev->parents;
-               while (p) {
-                       if (mask != cmit_flags(p->item))
-                               return 1;
-                       p = p->next;
-               }
-               return 0;
-       }
-       if (mask & basemask)
-               return 0;
-
-       return 1;
-}
-
-/*
- * Usage: git-rev-tree [--edges] [--cache <cache-file>] <commit-id> [<commit-id2>]
- *
- * The cache-file can be quite important for big trees. This is an
- * expensive operation if you have to walk the whole chain of
- * parents in a tree with a long revision history.
- */
-int main(int argc, char **argv)
-{
-       int i;
-       int nr = 0;
-       unsigned char sha1[MAX_COMMITS][20];
-       struct commit_list *list = NULL;
-
-       /*
-        * First - pick up all the revisions we can (both from
-        * caches and from commit file chains).
-        */
-       for (i = 1; i < argc ; i++) {
-               char *arg = argv[i];
-               struct commit *commit;
-
-               if (!strcmp(arg, "--cache")) {
-                       read_cache_file(argv[++i]);
-                       continue;
-               }
-
-               if (!strcmp(arg, "--edges")) {
-                       show_edges = 1;
-                       continue;
-               }
-
-               if (arg[0] == '^') {
-                       arg++;
-                       basemask |= 1<<nr;
-               }
-               if (nr >= MAX_COMMITS || get_sha1(arg, sha1[nr]))
-                       usage("git-rev-tree [--edges] [--cache <cache-file>] <commit-id> [<commit-id>]");
-
-               commit = lookup_commit_reference(sha1[nr]);
-               if (!commit || parse_commit(commit) < 0)
-                       die("bad commit object");
-               commit_list_insert(commit, &list);
-               nr++;
-       }
-
-       /*
-        * Parse all the commits in date order.
-        *
-        * We really should stop once we know enough, but that's a
-        * decision that isn't trivial to make.
-        */
-       while (list)
-               pop_most_recent_commit(&list, REACHABLE);
-
-       /*
-        * Now we have the maximal tree. Walk the different sha files back to the root.
-        */
-       for (i = 0; i < nr; i++)
-               mark_reachable(&lookup_commit_reference(sha1[i])->object, 1 << i);
-
-       /*
-        * Now print out the results..
-        */
-       for (i = 0; i < nr_objs; i++) {
-               struct object *obj = objs[i];
-               struct commit *commit;
-               struct commit_list *p;
-
-               if (obj->type != commit_type)
-                       continue;
-
-               commit = (struct commit *) obj;
-
-               if (!interesting(commit))
-                       continue;
-
-               printf("%lu %s:%d", commit->date, sha1_to_hex(obj->sha1),
-                                   cmit_flags(commit));
-               p = commit->parents;
-               while (p) {
-                       printf(" %s:%d", sha1_to_hex(p->item->object.sha1), 
-                              cmit_flags(p->item));
-                       p = p->next;
-               }
-               printf("\n");
-       }
-       return 0;
-}