* Re: How to manage heads on a remote repository?
From: David Symonds @ 2007-10-14 11:12 UTC (permalink / raw)
To: Theodore Tso; +Cc: git
In-Reply-To: <20071014110714.GA17368@thunk.org>
On 14/10/2007, Theodore Tso <tytso@mit.edu> wrote:
> On Sun, Oct 14, 2007 at 09:03:48PM +1000, David Symonds wrote:
> > git push <remote> :<branch_name>
> >
> > If the left side of the colon in a push refspec is empty, it deletes
> > the remote ref given by the right hand side.
>
> Cool, thanks! It's not in the git-push man page. I'll play with it
> some and then submit a patch update the man page.
Yes, it is, including in the examples section. Under the <refspec>
options description it says:
Pushing an empty <src> allows you to delete the <dst> ref from
the remote repository.
In the examples section, it says:
git push origin :experimental
Find a ref that matches experimental in the origin repository
(e.g. refs/heads/experimental), and delete it.
Dave.
^ permalink raw reply
* Re: How to manage heads on a remote repository?
From: Theodore Tso @ 2007-10-14 11:32 UTC (permalink / raw)
To: David Symonds; +Cc: git
In-Reply-To: <ee77f5c20710140412s1eb68991ke552995dbbd226b@mail.gmail.com>
On Sun, Oct 14, 2007 at 09:12:43PM +1000, David Symonds wrote:
> On 14/10/2007, Theodore Tso <tytso@mit.edu> wrote:
> > On Sun, Oct 14, 2007 at 09:03:48PM +1000, David Symonds wrote:
> > > git push <remote> :<branch_name>
> > >
> > > If the left side of the colon in a push refspec is empty, it deletes
> > > the remote ref given by the right hand side.
> >
> > Cool, thanks! It's not in the git-push man page. I'll play with it
> > some and then submit a patch update the man page.
>
> Yes, it is, including in the examples section.
Wow, I completely missed that! It would be nice if:
<refspec>
The canonical format of a <refspec> parameter is +?<src>:<dst>; that
is, an optional plus +, followed by the source ref, followed by a
colon :, followed by the destination ref.
.... mentioned that the source ref could be optional (just like it
explicitly says the '+' is optional)...
The <src> side can be an arbitrary "SHA1 expression" that can be
used as an argument to git-cat-file -t. E.g. master~4 (push four
parents before the current master head).
.... and I think the throwaway sentence at the end of the refspec
would be better at the end of the second paragraph above. I'll send a
patch.
Thanks for pointing that out!
- Ted
^ permalink raw reply
* Re: [PATCH] Add color to git-add--interactive diffs (Take 2: now without spurious line break!)
From: Wincent Colaiuta @ 2007-10-14 11:36 UTC (permalink / raw)
To: Tom Tobin; +Cc: Git Mailing List
In-Reply-To: <1192351494.7226.18.camel@athena>
El 14/10/2007, a las 10:44, Tom Tobin escribió:
> After banging my head against parsing colorized output of git-add-
> files,
> I gave up and implemented internal colorization keying off of the
> color.diff configuration.
Great!
> +sub parse_color {
You could simplify the manual escape sequence construction that
you're doing here by using Term::ANSIColor like the other patches
did. I see that git-send-email.perl uses that module too, so I guess
depending on that module is ok.
I also wonder whether the config code should be using the git.pm
module like git-send-email.perl and a couple others do (although it
would be slower than slurping in all the config in one shot like you
do; perhaps there's justification for a new function in git.pm that
wraps git-config --get-regexp...).
> +sub colorize_head_line {
> + my $line = shift @_;
> + if ($use_color) {
> + # git doesn't colorize these by default, soooo
> + # if ($line =~ /^\+/) {
> + # return parse_color($colorconfig{'color.diff.new'}) . "$line\e
> [m";
> + # }
> + # if ($line =~ /^-/) {
> + # return parse_color($colorconfig{'color.diff.old'}) . "$line\e
> [m";
> + # }
> + return parse_color($colorconfig{'color.diff.meta'}) . "$line\e[m";
> + }
> + return $line;
> +}
> +
> +sub colorize_hunk_line {
> + my $line = shift @_;
> + if ($use_color) {
> + if ($line =~ /^\+/) {
> + return parse_color($colorconfig{'color.diff.new'}) . "$line\e[m";
> + }
> + if ($line =~ /^-/) {
> + return parse_color($colorconfig{'color.diff.old'}) . "$line\e[m";
> + }
> + if ($line =~ /^@@ /) {
> + return parse_color($colorconfig{'color.diff.frag'}) . "$line\e[m";
> + }
> + }
> + return $line;
> +}
This is a good start but to completely match the colorized output
produced by diff it will need some additional logic; for example,
highlighting spurious whitespace. Search for
need_highlight_leading_space in diff.c and you'll see that the test
is basically for any space which precedes a tab in the leading
whitespace on newly inserted lines. In this case the spaces are
highlighted using the whitespace color (normally red background).
I don't know when color.diff.commit is ever used in diff output, but
perhaps that would need to be handled as well.
Cheers,
Wincent
^ permalink raw reply
* Re: [PATCH] [BUG FIXED] git-add (-a|-u) and -n support
From: Michael Witten @ 2007-10-14 12:11 UTC (permalink / raw)
To: git
In-Reply-To: <E1DCA1D1-1ED3-498A-A919-9EBAF3BA0870@mit.edu>
On 14 Oct 2007, at 6:26:28 AM, Michael Witten wrote:
> Hello,
>
> The git-add command doesn't handle -n when using -u.
>
> I fixed this and added -a for adding ALL files, not
> just those below the current directory (just like
> git-commit).
>
> The patch is below, but you can also download it from
> http://web.mit.edu/mfwitten/git/0001-git-add-now-understands-two-
> kinds-of-update.patch
>
Unfortunately, I introduced a bug.
The following:
> + if (show_only)
> + remove_file_from_cache(path);
> + if (verbose)
> + printf("remove '%s'\n", path);
Should be:
> + if (!show_only)
> + remove_file_from_cache(path);
> + if (verbose)
> + printf("remove '%s'\n", path);
The new patch is listed below:
(http://web.mit.edu/mfwitten/git/0001-git-add-now-understands-two-
kinds-of-update.patch)
From 6d7480062b1e1c513441d4bbc17a9a8b5d9b1c8f Mon Sep 17 00:00:00 2001
From: Michael Witten <mfwitten@mit.edu>
Date: Sun, 14 Oct 2007 06:13:20 -0400
Subject: [PATCH] git-add now understands two kinds of update:
-u: update as before
-a: update all as in a true 'git commit -a'
Also, -n works correctly now with the above options.
Signed-off-by: Michael Witten <mfwitten@mit.edu>
---
builtin-add.c | 69 +++++++++++++++++++++++++++++++++++++
+-------------------
1 files changed, 46 insertions(+), 23 deletions(-)
diff --git a/builtin-add.c b/builtin-add.c
index f9a6580..f180afe 100644
--- a/builtin-add.c
+++ b/builtin-add.c
@@ -13,10 +13,11 @@
#include "commit.h"
#include "revision.h"
+enum update_type {NONE, ALL, CURRENT_DIRECTORY};
+
static const char builtin_add_usage[] =
"git-add [-n] [-v] [-f] [--interactive | -i] [-u] [--refresh] [--]
<filepattern>...";
-static int take_worktree_changes;
static const char *excludes_file;
static void prune_directory(struct dir_struct *dir, const char
**pathspec, int prefix)
@@ -83,40 +84,57 @@ static void fill_directory(struct dir_struct
*dir, const char **pathspec,
static void update_callback(struct diff_queue_struct *q,
struct diff_options *opt, void *cbdata)
{
- int i, verbose;
-
- verbose = *((int *)cbdata);
+ int i;
+
+ int* options = (int*)cbdata;
+ int verbose = options[0];
+ int show_only = options[1];
+
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
const char *path = p->one->path;
- switch (p->status) {
- default:
- die("unexpected diff status %c", p->status);
- case DIFF_STATUS_UNMERGED:
- case DIFF_STATUS_MODIFIED:
- case DIFF_STATUS_TYPE_CHANGED:
- add_file_to_cache(path, verbose);
- break;
- case DIFF_STATUS_DELETED:
- remove_file_from_cache(path);
- if (verbose)
- printf("remove '%s'\n", path);
- break;
+
+ switch (p->status) {
+ case DIFF_STATUS_UNMERGED:
+ case DIFF_STATUS_MODIFIED:
+ case DIFF_STATUS_TYPE_CHANGED:
+ if (show_only)
+ printf("add '%s'\n", path);
+ else
+ add_file_to_cache(path, verbose);
+ break;
+
+ case DIFF_STATUS_DELETED:
+ if (verbose)
+ printf("remove '%s'\n", path);
+ if (!show_only)
+ remove_file_from_cache(path);
+ break;
+
+ default:
+ die("unexpected diff status %c", p->status);
}
}
}
-static void update(int verbose, const char *prefix, const char **files)
+static void update(enum update_type type, int verbose, int show_only,
+ const char *prefix, const char **files)
{
struct rev_info rev;
+ int callback_options[] = {verbose, show_only};
+
init_revisions(&rev, prefix);
setup_revisions(0, NULL, &rev, NULL);
- rev.prune_data = get_pathspec(prefix, files);
+
+ rev.prune_data = type == ALL ? NULL : get_pathspec(prefix, files);
+
rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
rev.diffopt.format_callback = update_callback;
- rev.diffopt.format_callback_data = &verbose;
+ rev.diffopt.format_callback_data = callback_options;
+
if (read_cache() < 0)
die("index file corrupt");
+
run_diff_files(&rev, 0);
}
@@ -158,6 +176,7 @@ int cmd_add(int argc, const char **argv, const
char *prefix)
{
int i, newfd;
int verbose = 0, show_only = 0, ignored_too = 0, refresh_only = 0;
+ enum update_type update_type = NONE;
const char **pathspec;
struct dir_struct dir;
int add_interactive = 0;
@@ -201,8 +220,12 @@ int cmd_add(int argc, const char **argv, const
char *prefix)
verbose = 1;
continue;
}
+ if (!strcmp(arg, "-a")) {
+ update_type = ALL;
+ continue;
+ }
if (!strcmp(arg, "-u")) {
- take_worktree_changes = 1;
+ update_type = CURRENT_DIRECTORY;
continue;
}
if (!strcmp(arg, "--refresh")) {
@@ -212,8 +235,8 @@ int cmd_add(int argc, const char **argv, const
char *prefix)
usage(builtin_add_usage);
}
- if (take_worktree_changes) {
- update(verbose, prefix, argv + i);
+ if (update_type) {
+ update(update_type, verbose, show_only, prefix, argv + i);
goto finish;
}
--
1.5.3.4.206.g58ba4-dirty
^ permalink raw reply related
* [PATCH 0/7] Bisect dunno
From: Christian Couder @ 2007-10-14 12:28 UTC (permalink / raw)
To: Junio Hamano, Johannes Schindelin; +Cc: git
Hi all,
Here is my bisect dunno patch series again.
The changes since last time are the following:
[PATCH 1/7] rev-list: implement --bisect-all
[PATCH 2/7] Bisect: fix some white spaces and empty lines breakages.
-> No change.
[PATCH 3/7] Bisect: implement "bisect dunno" to mark untestable revisions.
-> Added dunno stuff in "bisect_replay" that I had forgotten.
-> Use "bisect_write_good" and "bisect_write_bad" in "bisect_replay"
while at it.
[PATCH 4/7] Bisect: factorise "bisect_write_*" functions.
[PATCH 5/7] Bisect: factorise some logging into "bisect_write".
[PATCH 6/7] Bisect: factorise "bisect_{bad,good,dunno}" into "bisect_state".
-> Some new factorisation and clean up work.
[PATCH 7/7] Bisect: add "bisect dunno" to the documentation.
-> Document "bisect dunno" and fix some short usage descriptions.
Regards,
Christian.
^ permalink raw reply
* [PATCH 1/7] rev-list: implement --bisect-all
From: Christian Couder @ 2007-10-14 12:28 UTC (permalink / raw)
To: Junio Hamano, Johannes Schindelin; +Cc: git
This is Junio's patch with some stuff to make --bisect-all
compatible with --bisect-vars.
This option makes it possible to see all the potential
bisection points. The best ones are displayed first.
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
---
builtin-rev-list.c | 100 ++++++++++++++++++++++++++++++++++++++++++++-------
log-tree.c | 2 +-
log-tree.h | 1 +
3 files changed, 88 insertions(+), 15 deletions(-)
diff --git a/builtin-rev-list.c b/builtin-rev-list.c
index 33726b8..4439332 100644
--- a/builtin-rev-list.c
+++ b/builtin-rev-list.c
@@ -9,6 +9,7 @@
#include "revision.h"
#include "list-objects.h"
#include "builtin.h"
+#include "log-tree.h"
/* bits #0-15 in revision.h */
@@ -38,7 +39,8 @@ static const char rev_list_usage[] =
" --left-right\n"
" special purpose:\n"
" --bisect\n"
-" --bisect-vars"
+" --bisect-vars\n"
+" --bisect-all"
;
static struct rev_info revs;
@@ -74,6 +76,7 @@ static void show_commit(struct commit *commit)
parents = parents->next;
}
}
+ show_decorations(commit);
if (revs.commit_format == CMIT_FMT_ONELINE)
putchar(' ');
else
@@ -278,6 +281,57 @@ static struct commit_list *best_bisection(struct commit_list *list, int nr)
return best;
}
+struct commit_dist {
+ struct commit *commit;
+ int distance;
+};
+
+static int compare_commit_dist(const void *a_, const void *b_)
+{
+ struct commit_dist *a, *b;
+
+ a = (struct commit_dist *)a_;
+ b = (struct commit_dist *)b_;
+ if (a->distance != b->distance)
+ return b->distance - a->distance; /* desc sort */
+ return hashcmp(a->commit->object.sha1, b->commit->object.sha1);
+}
+
+static struct commit_list *best_bisection_sorted(struct commit_list *list, int nr)
+{
+ struct commit_list *p;
+ struct commit_dist *array = xcalloc(nr, sizeof(*array));
+ int cnt, i;
+
+ for (p = list, cnt = 0; p; p = p->next) {
+ int distance;
+ unsigned flags = p->item->object.flags;
+
+ if (revs.prune_fn && !(flags & TREECHANGE))
+ continue;
+ distance = weight(p);
+ if (nr - distance < distance)
+ distance = nr - distance;
+ array[cnt].commit = p->item;
+ array[cnt].distance = distance;
+ cnt++;
+ }
+ qsort(array, cnt, sizeof(*array), compare_commit_dist);
+ for (p = list, i = 0; i < cnt; i++) {
+ struct name_decoration *r = xmalloc(sizeof(*r) + 100);
+ struct object *obj = &(array[i].commit->object);
+
+ sprintf(r->name, "dist=%d", array[i].distance);
+ r->next = add_decoration(&name_decoration, obj, r);
+ p->item = array[i].commit;
+ p = p->next;
+ }
+ if (p)
+ p->next = NULL;
+ free(array);
+ return list;
+}
+
/*
* zero or positive weight is the number of interesting commits it can
* reach, including itself. Especially, weight = 0 means it does not
@@ -292,7 +346,8 @@ static struct commit_list *best_bisection(struct commit_list *list, int nr)
* or positive distance.
*/
static struct commit_list *do_find_bisection(struct commit_list *list,
- int nr, int *weights)
+ int nr, int *weights,
+ int find_all)
{
int n, counted;
struct commit_list *p;
@@ -351,7 +406,7 @@ static struct commit_list *do_find_bisection(struct commit_list *list,
clear_distance(list);
/* Does it happen to be at exactly half-way? */
- if (halfway(p, nr))
+ if (!find_all && halfway(p, nr))
return p;
counted++;
}
@@ -389,19 +444,22 @@ static struct commit_list *do_find_bisection(struct commit_list *list,
weight_set(p, weight(q));
/* Does it happen to be at exactly half-way? */
- if (halfway(p, nr))
+ if (!find_all && halfway(p, nr))
return p;
}
}
show_list("bisection 2 counted all", counted, nr, list);
- /* Then find the best one */
- return best_bisection(list, nr);
+ if (!find_all)
+ return best_bisection(list, nr);
+ else
+ return best_bisection_sorted(list, nr);
}
static struct commit_list *find_bisection(struct commit_list *list,
- int *reaches, int *all)
+ int *reaches, int *all,
+ int find_all)
{
int nr, on_list;
struct commit_list *p, *best, *next, *last;
@@ -434,14 +492,13 @@ static struct commit_list *find_bisection(struct commit_list *list,
weights = xcalloc(on_list, sizeof(*weights));
/* Do the real work of finding bisection commit. */
- best = do_find_bisection(list, nr, weights);
-
+ best = do_find_bisection(list, nr, weights, find_all);
if (best) {
- best->next = NULL;
+ if (!find_all)
+ best->next = NULL;
*reaches = weight(best);
}
free(weights);
-
return best;
}
@@ -468,6 +525,7 @@ int cmd_rev_list(int argc, const char **argv, const char *prefix)
int i;
int read_from_stdin = 0;
int bisect_show_vars = 0;
+ int bisect_find_all = 0;
git_config(git_default_config);
init_revisions(&revs, prefix);
@@ -490,6 +548,11 @@ int cmd_rev_list(int argc, const char **argv, const char *prefix)
bisect_list = 1;
continue;
}
+ if (!strcmp(arg, "--bisect-all")) {
+ bisect_list = 1;
+ bisect_find_all = 1;
+ continue;
+ }
if (!strcmp(arg, "--bisect-vars")) {
bisect_list = 1;
bisect_show_vars = 1;
@@ -536,9 +599,11 @@ int cmd_rev_list(int argc, const char **argv, const char *prefix)
if (bisect_list) {
int reaches = reaches, all = all;
- revs.commits = find_bisection(revs.commits, &reaches, &all);
+ revs.commits = find_bisection(revs.commits, &reaches, &all,
+ bisect_find_all);
if (bisect_show_vars) {
int cnt;
+ char hex[41];
if (!revs.commits)
return 1;
/*
@@ -550,15 +615,22 @@ int cmd_rev_list(int argc, const char **argv, const char *prefix)
* A bisect set of size N has (N-1) commits further
* to test, as we already know one bad one.
*/
- cnt = all-reaches;
+ cnt = all - reaches;
if (cnt < reaches)
cnt = reaches;
+ strcpy(hex, sha1_to_hex(revs.commits->item->object.sha1));
+
+ if (bisect_find_all) {
+ traverse_commit_list(&revs, show_commit, show_object);
+ printf("------\n");
+ }
+
printf("bisect_rev=%s\n"
"bisect_nr=%d\n"
"bisect_good=%d\n"
"bisect_bad=%d\n"
"bisect_all=%d\n",
- sha1_to_hex(revs.commits->item->object.sha1),
+ hex,
cnt - 1,
all - reaches - 1,
reaches - 1,
diff --git a/log-tree.c b/log-tree.c
index 2319154..f766758 100644
--- a/log-tree.c
+++ b/log-tree.c
@@ -15,7 +15,7 @@ static void show_parents(struct commit *commit, int abbrev)
}
}
-static void show_decorations(struct commit *commit)
+void show_decorations(struct commit *commit)
{
const char *prefix;
struct name_decoration *decoration;
diff --git a/log-tree.h b/log-tree.h
index e82b56a..b33f7cd 100644
--- a/log-tree.h
+++ b/log-tree.h
@@ -12,5 +12,6 @@ int log_tree_diff_flush(struct rev_info *);
int log_tree_commit(struct rev_info *, struct commit *);
int log_tree_opt_parse(struct rev_info *, const char **, int);
void show_log(struct rev_info *opt, const char *sep);
+void show_decorations(struct commit *commit);
#endif
--
1.5.3.4.213.g68ad5
^ permalink raw reply related
* [PATCH 2/7] Bisect: fix some white spaces and empty lines breakages.
From: Christian Couder @ 2007-10-14 12:29 UTC (permalink / raw)
To: Junio Hamano, Johannes Schindelin; +Cc: git
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
---
git-bisect.sh | 17 ++++++++---------
1 files changed, 8 insertions(+), 9 deletions(-)
diff --git a/git-bisect.sh b/git-bisect.sh
index 388887a..436ccf6 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -64,7 +64,7 @@ bisect_start() {
branch=`cat "$GIT_DIR/head-name"`
else
branch=master
- fi
+ fi
git checkout $branch || exit
;;
refs/heads/*)
@@ -95,11 +95,11 @@ bisect_start() {
arg="$1"
case "$arg" in
--)
- shift
+ shift
break
;;
*)
- rev=$(git rev-parse --verify "$arg^{commit}" 2>/dev/null) || {
+ rev=$(git rev-parse --verify "$arg^{commit}" 2>/dev/null) || {
test $has_double_dash -eq 1 &&
die "'$arg' does not appear to be a valid revision"
break
@@ -110,10 +110,10 @@ bisect_start() {
else
bisect_write_good "$rev"
fi
- shift
+ shift
;;
esac
- done
+ done
sq "$@" >"$GIT_DIR/BISECT_NAMES"
echo "git-bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG"
@@ -143,7 +143,7 @@ bisect_write_bad() {
bisect_good() {
bisect_autostart
- case "$#" in
+ case "$#" in
0) revs=$(git rev-parse --verify HEAD) || exit ;;
*) revs=$(git rev-parse --revs-only --no-flags "$@") &&
test '' != "$revs" || die "Bad rev input: $@" ;;
@@ -153,7 +153,6 @@ bisect_good() {
rev=$(git rev-parse --verify "$rev^{commit}") || exit
bisect_write_good "$rev"
echo "git-bisect good $rev" >>"$GIT_DIR/BISECT_LOG"
-
done
bisect_auto_next
}
@@ -207,7 +206,7 @@ bisect_auto_next() {
}
bisect_next() {
- case "$#" in 0) ;; *) usage ;; esac
+ case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
bisect_next_check good
@@ -255,7 +254,7 @@ bisect_reset() {
exit 1
}
branch="$1" ;;
- *)
+ *)
usage ;;
esac
if git checkout "$branch"; then
--
1.5.3.4.213.g68ad5
^ permalink raw reply related
* [PATCH 3/7] Bisect: implement "bisect dunno" to mark untestable revisions.
From: Christian Couder @ 2007-10-14 12:29 UTC (permalink / raw)
To: Junio Hamano, Johannes Schindelin; +Cc: git
When there are some dunno revisions, we add the '--bisect-all'
option to "git rev-list --bisect-vars". Then we filter out the
dunno revisions from the result of the rev-list command, and we
modify the "bisect_rev" var accordingly.
We don't always use "--bisect-all" because it is slower
than "--bisect-vars" or "--bisect".
When we cannot find for sure the first bad commit because of
dunno commits, we print the hash of each possible first bad
commit and then we exit with code 2.
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
---
git-bisect.sh | 125 ++++++++++++++++++++++++++++++++++++++++--
t/t6030-bisect-porcelain.sh | 71 ++++++++++++++++++++++++
2 files changed, 190 insertions(+), 6 deletions(-)
diff --git a/git-bisect.sh b/git-bisect.sh
index 436ccf6..94534e6 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -17,6 +17,8 @@ git bisect replay <logfile>
replay bisection log.
git bisect log
show bisect log.
+git bisect dunno [<rev>...]
+ mark <rev>... untestable revisions.
git bisect run <cmd>...
use <cmd>... to automatically bisect.'
@@ -163,6 +165,28 @@ bisect_write_good() {
echo "# good: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
}
+bisect_dunno() {
+ bisect_autostart
+ case "$#" in
+ 0) revs=$(git rev-parse --verify HEAD) || exit ;;
+ *) revs=$(git rev-parse --revs-only --no-flags "$@") &&
+ test '' != "$revs" || die "Bad rev input: $@" ;;
+ esac
+ for rev in $revs
+ do
+ rev=$(git rev-parse --verify "$rev^{commit}") || exit
+ bisect_write_dunno "$rev"
+ echo "git-bisect dunno $rev" >>"$GIT_DIR/BISECT_LOG"
+ done
+ bisect_auto_next
+}
+
+bisect_write_dunno() {
+ rev="$1"
+ echo "$rev" >"$GIT_DIR/refs/bisect/dunno-$rev"
+ echo "# dunno: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
+}
+
bisect_next_check() {
missing_good= missing_bad=
git show-ref -q --verify refs/bisect/bad || missing_bad=t
@@ -205,17 +229,97 @@ bisect_auto_next() {
bisect_next_check && bisect_next || :
}
+filter_dunno() {
+ _eval="$1"
+ _dunno="$2"
+
+ if [ -z "$_dunno" ]; then
+ eval $_eval
+ return
+ fi
+
+ # Let's parse the output of:
+ # "git rev-list --bisect-vars --bisect-all ..."
+ eval $_eval | while read hash line
+ do
+ case "$VARS,$FOUND,$TRIED,$hash" in
+ # We display some vars.
+ 1,*,*,*) echo "$hash $line" ;;
+
+ # Split line.
+ ,*,*,---*) ;;
+
+ # We had nothing to search.
+ ,,,bisect_rev*)
+ echo "bisect_rev="
+ VARS=1
+ ;;
+
+ # We did not find a good bisect rev.
+ # This should happen only if the "bad"
+ # commit is also a "dunno" commit.
+ ,,*,bisect_rev*)
+ echo "bisect_rev=$TRIED"
+ VARS=1
+ ;;
+
+ # We are searching.
+ ,,*,*)
+ TRIED="${TRIED:+$TRIED|}$hash"
+ case "$_dunno" in
+ *$hash*) ;;
+ *)
+ echo "bisect_rev=$hash"
+ echo "bisect_tried=\"$TRIED\""
+ FOUND=1
+ ;;
+ esac
+ ;;
+
+ # We have already found a rev to be tested.
+ ,1,*,bisect_rev*) VARS=1 ;;
+ ,1,*,*) ;;
+
+ # ???
+ *) die "filter_dunno error " \
+ "VARS: '$VARS' " \
+ "FOUND: '$FOUND' " \
+ "TRIED: '$TRIED' " \
+ "hash: '$hash' " \
+ "line: '$line'"
+ ;;
+ esac
+ done
+}
+
+exit_if_dunno_commits () {
+ _tried=$1
+ if expr "$_tried" : ".*[|].*" > /dev/null ; then
+ echo "There are only 'dunno' commit left to test."
+ echo "The first bad commit could be any of:"
+ echo "$_tried" | sed -e 's/[|]/\n/g'
+ echo "We cannot bisect more!"
+ exit 2
+ fi
+}
+
bisect_next() {
case "$#" in 0) ;; *) usage ;; esac
bisect_autostart
bisect_next_check good
+ dunno=$(git for-each-ref --format='%(objectname)' \
+ "refs/bisect/dunno-*" | tr '[\012]' ' ') || exit
+
+ BISECT_OPT=''
+ test -n "$dunno" && BISECT_OPT='--bisect-all'
+
bad=$(git rev-parse --verify refs/bisect/bad) &&
good=$(git for-each-ref --format='^%(objectname)' \
"refs/bisect/good-*" | tr '[\012]' ' ') &&
- eval="git rev-list --bisect-vars $good $bad --" &&
+ eval="git rev-list --bisect-vars $BISECT_OPT $good $bad --" &&
eval="$eval $(cat "$GIT_DIR/BISECT_NAMES")" &&
- eval=$(eval "$eval") &&
+ eval=$(filter_dunno "$eval" "$dunno") &&
eval "$eval" || exit
if [ -z "$bisect_rev" ]; then
@@ -223,11 +327,16 @@ bisect_next() {
exit 1
fi
if [ "$bisect_rev" = "$bad" ]; then
+ exit_if_dunno_commits "$bisect_tried"
echo "$bisect_rev is first bad commit"
git diff-tree --pretty $bisect_rev
exit 0
fi
+ # We should exit here only if the "bad"
+ # commit is also a "dunno" commit (see above).
+ exit_if_dunno_commits "$bisect_rev"
+
echo "Bisecting: $bisect_nr revisions left to test after this"
echo "$bisect_rev" >"$GIT_DIR/refs/heads/new-bisect"
git checkout -q new-bisect || exit
@@ -286,15 +395,17 @@ bisect_replay () {
eval "$cmd"
;;
good)
- echo "$rev" >"$GIT_DIR/refs/bisect/good-$rev"
- echo "# good: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
+ bisect_write_good "$rev"
echo "git-bisect good $rev" >>"$GIT_DIR/BISECT_LOG"
;;
bad)
- echo "$rev" >"$GIT_DIR/refs/bisect/bad"
- echo "# bad: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
+ bisect_write_bad "$rev"
echo "git-bisect bad $rev" >>"$GIT_DIR/BISECT_LOG"
;;
+ dunno)
+ bisect_write_dunno "$rev"
+ echo "git-bisect dunno $rev" >>"$GIT_DIR/BISECT_LOG"
+ ;;
*)
echo >&2 "?? what are you talking about?"
exit 1 ;;
@@ -362,6 +473,8 @@ case "$#" in
bisect_bad "$@" ;;
good)
bisect_good "$@" ;;
+ dunno)
+ bisect_dunno "$@" ;;
next)
# Not sure we want "next" at the UI level anymore.
bisect_next "$@" ;;
diff --git a/t/t6030-bisect-porcelain.sh b/t/t6030-bisect-porcelain.sh
index 03cdba5..7f41a46 100755
--- a/t/t6030-bisect-porcelain.sh
+++ b/t/t6030-bisect-porcelain.sh
@@ -71,6 +71,63 @@ test_expect_success 'bisect start with one bad and good' '
git bisect next
'
+# $HASH1 is good, $HASH4 is bad, we dunno about $HASH3
+# but $HASH2 is bad,
+# so we should find $HASH2 as the first bad commit
+test_expect_success 'bisect dunno: successfull result' '
+ git bisect reset &&
+ git bisect start $HASH4 $HASH1 &&
+ git bisect dunno &&
+ git bisect bad > my_bisect_log.txt &&
+ grep "$HASH2 is first bad commit" my_bisect_log.txt &&
+ git bisect reset
+'
+
+# $HASH1 is good, $HASH4 is bad, we dunno about $HASH3 and $HASH2
+# so we should not be able to tell the first bad commit
+# among $HASH2, $HASH3 and $HASH4
+test_expect_success 'bisect dunno: cannot tell between 3 commits' '
+ git bisect start $HASH4 $HASH1 &&
+ git bisect dunno || return 1
+
+ if git bisect dunno > my_bisect_log.txt
+ then
+ echo Oops, should have failed.
+ false
+ else
+ test $? -eq 2 &&
+ grep "first bad commit could be any of" my_bisect_log.txt &&
+ ! grep $HASH1 my_bisect_log.txt &&
+ grep $HASH2 my_bisect_log.txt &&
+ grep $HASH3 my_bisect_log.txt &&
+ grep $HASH4 my_bisect_log.txt &&
+ git bisect reset
+ fi
+'
+
+# $HASH1 is good, $HASH4 is bad, we dunno about $HASH3
+# but $HASH2 is good,
+# so we should not be able to tell the first bad commit
+# among $HASH3 and $HASH4
+test_expect_success 'bisect dunno: cannot tell between 2 commits' '
+ git bisect start $HASH4 $HASH1 &&
+ git bisect dunno || return 1
+
+ if git bisect good > my_bisect_log.txt
+ then
+ echo Oops, should have failed.
+ false
+ else
+ test $? -eq 2 &&
+ grep "first bad commit could be any of" my_bisect_log.txt &&
+ ! grep $HASH1 my_bisect_log.txt &&
+ ! grep $HASH2 my_bisect_log.txt &&
+ grep $HASH3 my_bisect_log.txt &&
+ grep $HASH4 my_bisect_log.txt &&
+ git bisect reset
+ fi
+'
+
# We want to automatically find the commit that
# introduced "Another" into hello.
test_expect_success \
@@ -99,6 +156,20 @@ test_expect_success \
grep "$HASH4 is first bad commit" my_bisect_log.txt &&
git bisect reset'
+# $HASH1 is good, $HASH5 is bad, we dunno about $HASH3
+# but $HASH4 is good,
+# so we should find $HASH5 as the first bad commit
+HASH5=
+test_expect_success 'bisect dunno: add line and then a new test' '
+ add_line_into_file "5: Another new line." hello &&
+ HASH5=$(git rev-parse --verify HEAD) &&
+ git bisect start $HASH5 $HASH1 &&
+ git bisect dunno &&
+ git bisect good > my_bisect_log.txt &&
+ grep "$HASH5 is first bad commit" my_bisect_log.txt &&
+ git bisect reset
+'
+
#
#
test_done
--
1.5.3.4.213.g68ad5
^ permalink raw reply related
* [PATCH 4/7] Bisect: factorise "bisect_write_*" functions.
From: Christian Couder @ 2007-10-14 12:29 UTC (permalink / raw)
To: Junio Hamano, Johannes Schindelin; +Cc: git
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
---
git-bisect.sh | 46 ++++++++++++++++++++--------------------------
1 files changed, 20 insertions(+), 26 deletions(-)
diff --git a/git-bisect.sh b/git-bisect.sh
index 94534e6..847250c 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -108,9 +108,9 @@ bisect_start() {
}
if [ $bad_seen -eq 0 ]; then
bad_seen=1
- bisect_write_bad "$rev"
+ bisect_write 'bad' "$rev"
else
- bisect_write_good "$rev"
+ bisect_write 'good' "$rev"
fi
shift
;;
@@ -122,6 +122,18 @@ bisect_start() {
bisect_auto_next
}
+bisect_write() {
+ state="$1"
+ rev="$2"
+ case "$state" in
+ bad) tag="$state" ;;
+ good|dunno) tag="$state"-"$rev" ;;
+ *) die "Bad bisect_write argument: $state" ;;
+ esac
+ echo "$rev" >"$GIT_DIR/refs/bisect/$tag"
+ echo "# $state: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
+}
+
bisect_bad() {
bisect_autostart
case "$#" in
@@ -132,17 +144,11 @@ bisect_bad() {
*)
usage ;;
esac || exit
- bisect_write_bad "$rev"
+ bisect_write 'bad' "$rev"
echo "git-bisect bad $rev" >>"$GIT_DIR/BISECT_LOG"
bisect_auto_next
}
-bisect_write_bad() {
- rev="$1"
- echo "$rev" >"$GIT_DIR/refs/bisect/bad"
- echo "# bad: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_good() {
bisect_autostart
case "$#" in
@@ -153,18 +159,12 @@ bisect_good() {
for rev in $revs
do
rev=$(git rev-parse --verify "$rev^{commit}") || exit
- bisect_write_good "$rev"
+ bisect_write 'good' "$rev"
echo "git-bisect good $rev" >>"$GIT_DIR/BISECT_LOG"
done
bisect_auto_next
}
-bisect_write_good() {
- rev="$1"
- echo "$rev" >"$GIT_DIR/refs/bisect/good-$rev"
- echo "# good: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_dunno() {
bisect_autostart
case "$#" in
@@ -175,18 +175,12 @@ bisect_dunno() {
for rev in $revs
do
rev=$(git rev-parse --verify "$rev^{commit}") || exit
- bisect_write_dunno "$rev"
+ bisect_write 'dunno' "$rev"
echo "git-bisect dunno $rev" >>"$GIT_DIR/BISECT_LOG"
done
bisect_auto_next
}
-bisect_write_dunno() {
- rev="$1"
- echo "$rev" >"$GIT_DIR/refs/bisect/dunno-$rev"
- echo "# dunno: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
-}
-
bisect_next_check() {
missing_good= missing_bad=
git show-ref -q --verify refs/bisect/bad || missing_bad=t
@@ -395,15 +389,15 @@ bisect_replay () {
eval "$cmd"
;;
good)
- bisect_write_good "$rev"
+ bisect_write 'good' "$rev"
echo "git-bisect good $rev" >>"$GIT_DIR/BISECT_LOG"
;;
bad)
- bisect_write_bad "$rev"
+ bisect_write 'bad' "$rev"
echo "git-bisect bad $rev" >>"$GIT_DIR/BISECT_LOG"
;;
dunno)
- bisect_write_dunno "$rev"
+ bisect_write 'dunno' "$rev"
echo "git-bisect dunno $rev" >>"$GIT_DIR/BISECT_LOG"
;;
*)
--
1.5.3.4.213.g68ad5
^ permalink raw reply related
* [PATCH 5/7] Bisect: factorise some logging into "bisect_write".
From: Christian Couder @ 2007-10-14 12:29 UTC (permalink / raw)
To: Junio Hamano, Johannes Schindelin; +Cc: git
Also use "die" instead of "echo >&2 something ; exit 1".
And simplify "bisect_replay".
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
---
git-bisect.sh | 46 +++++++++++++---------------------------------
1 files changed, 13 insertions(+), 33 deletions(-)
diff --git a/git-bisect.sh b/git-bisect.sh
index 847250c..e12125f 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -106,12 +106,11 @@ bisect_start() {
die "'$arg' does not appear to be a valid revision"
break
}
- if [ $bad_seen -eq 0 ]; then
- bad_seen=1
- bisect_write 'bad' "$rev"
- else
- bisect_write 'good' "$rev"
- fi
+ case $bad_seen in
+ 0) state='bad' ; bad_seen=1 ;;
+ *) state='good' ;;
+ esac
+ bisect_write "$state" "$rev" 'nolog'
shift
;;
esac
@@ -132,6 +131,7 @@ bisect_write() {
esac
echo "$rev" >"$GIT_DIR/refs/bisect/$tag"
echo "# $state: "$(git show-branch $rev) >>"$GIT_DIR/BISECT_LOG"
+ test -z "$nolog" && echo "git-bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
bisect_bad() {
@@ -145,7 +145,6 @@ bisect_bad() {
usage ;;
esac || exit
bisect_write 'bad' "$rev"
- echo "git-bisect bad $rev" >>"$GIT_DIR/BISECT_LOG"
bisect_auto_next
}
@@ -160,7 +159,6 @@ bisect_good() {
do
rev=$(git rev-parse --verify "$rev^{commit}") || exit
bisect_write 'good' "$rev"
- echo "git-bisect good $rev" >>"$GIT_DIR/BISECT_LOG"
done
bisect_auto_next
}
@@ -176,7 +174,6 @@ bisect_dunno() {
do
rev=$(git rev-parse --verify "$rev^{commit}") || exit
bisect_write 'dunno' "$rev"
- echo "git-bisect dunno $rev" >>"$GIT_DIR/BISECT_LOG"
done
bisect_auto_next
}
@@ -352,10 +349,8 @@ bisect_reset() {
else
branch=master
fi ;;
- 1) git show-ref --verify --quiet -- "refs/heads/$1" || {
- echo >&2 "$1 does not seem to be a valid branch"
- exit 1
- }
+ 1) git show-ref --verify --quiet -- "refs/heads/$1" ||
+ die "$1 does not seem to be a valid branch"
branch="$1" ;;
*)
usage ;;
@@ -375,10 +370,7 @@ bisect_clean_state() {
}
bisect_replay () {
- test -r "$1" || {
- echo >&2 "cannot read $1 for replaying"
- exit 1
- }
+ test -r "$1" || die "cannot read $1 for replaying"
bisect_reset
while read bisect command rev
do
@@ -386,23 +378,11 @@ bisect_replay () {
case "$command" in
start)
cmd="bisect_start $rev"
- eval "$cmd"
- ;;
- good)
- bisect_write 'good' "$rev"
- echo "git-bisect good $rev" >>"$GIT_DIR/BISECT_LOG"
- ;;
- bad)
- bisect_write 'bad' "$rev"
- echo "git-bisect bad $rev" >>"$GIT_DIR/BISECT_LOG"
- ;;
- dunno)
- bisect_write 'dunno' "$rev"
- echo "git-bisect dunno $rev" >>"$GIT_DIR/BISECT_LOG"
- ;;
+ eval "$cmd" ;;
+ good|bad|dunno)
+ bisect_write "$command" "$rev" ;;
*)
- echo >&2 "?? what are you talking about?"
- exit 1 ;;
+ die "?? what are you talking about?" ;;
esac
done <"$1"
bisect_auto_next
--
1.5.3.4.213.g68ad5
^ permalink raw reply related
* [PATCH 6/7] Bisect: factorise "bisect_{bad,good,dunno}" into "bisect_state".
From: Christian Couder @ 2007-10-14 12:30 UTC (permalink / raw)
To: Junio Hamano, Johannes Schindelin; +Cc: git
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
---
git-bisect.sh | 80 +++++++++++++++++++++-----------------------------------
1 files changed, 30 insertions(+), 50 deletions(-)
diff --git a/git-bisect.sh b/git-bisect.sh
index e12125f..6a5ec5b 100755
--- a/git-bisect.sh
+++ b/git-bisect.sh
@@ -134,47 +134,33 @@ bisect_write() {
test -z "$nolog" && echo "git-bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
}
-bisect_bad() {
+bisect_state() {
bisect_autostart
- case "$#" in
- 0)
- rev=$(git rev-parse --verify HEAD) ;;
- 1)
- rev=$(git rev-parse --verify "$1^{commit}") ;;
+ state=$1
+ case "$#,$state" in
+ 0,*)
+ die "Please call 'bisect_state' with at least one argument." ;;
+ 1,bad|1,good|1,dunno)
+ rev=$(git rev-parse --verify HEAD) ||
+ die "Bad rev input: HEAD"
+ bisect_write "$state" "$rev" ;;
+ 2,bad)
+ rev=$(git rev-parse --verify "$2^{commit}") ||
+ die "Bad rev input: $2"
+ bisect_write "$state" "$rev" ;;
+ *,good|*,dunno)
+ shift
+ revs=$(git rev-parse --revs-only --no-flags "$@") &&
+ test '' != "$revs" || die "Bad rev input: $@"
+ for rev in $revs
+ do
+ rev=$(git rev-parse --verify "$rev^{commit}") ||
+ die "Bad rev commit: $rev^{commit}"
+ bisect_write "$state" "$rev"
+ done ;;
*)
usage ;;
- esac || exit
- bisect_write 'bad' "$rev"
- bisect_auto_next
-}
-
-bisect_good() {
- bisect_autostart
- case "$#" in
- 0) revs=$(git rev-parse --verify HEAD) || exit ;;
- *) revs=$(git rev-parse --revs-only --no-flags "$@") &&
- test '' != "$revs" || die "Bad rev input: $@" ;;
esac
- for rev in $revs
- do
- rev=$(git rev-parse --verify "$rev^{commit}") || exit
- bisect_write 'good' "$rev"
- done
- bisect_auto_next
-}
-
-bisect_dunno() {
- bisect_autostart
- case "$#" in
- 0) revs=$(git rev-parse --verify HEAD) || exit ;;
- *) revs=$(git rev-parse --revs-only --no-flags "$@") &&
- test '' != "$revs" || die "Bad rev input: $@" ;;
- esac
- for rev in $revs
- do
- rev=$(git rev-parse --verify "$rev^{commit}") || exit
- bisect_write 'dunno' "$rev"
- done
bisect_auto_next
}
@@ -404,17 +390,15 @@ bisect_run () {
exit $res
fi
- # Use "bisect_good" or "bisect_bad"
- # depending on run success or failure.
+ # Find current state depending on run success or failure.
if [ $res -gt 0 ]; then
- next_bisect='bisect_bad'
+ state='bad'
else
- next_bisect='bisect_good'
+ state='good'
fi
- # We have to use a subshell because bisect_good or
- # bisect_bad functions can exit.
- ( $next_bisect > "$GIT_DIR/BISECT_RUN" )
+ # We have to use a subshell because "bisect_state" can exit.
+ ( bisect_state $state > "$GIT_DIR/BISECT_RUN" )
res=$?
cat "$GIT_DIR/BISECT_RUN"
@@ -443,12 +427,8 @@ case "$#" in
case "$cmd" in
start)
bisect_start "$@" ;;
- bad)
- bisect_bad "$@" ;;
- good)
- bisect_good "$@" ;;
- dunno)
- bisect_dunno "$@" ;;
+ bad|good|dunno)
+ bisect_state "$cmd" "$@" ;;
next)
# Not sure we want "next" at the UI level anymore.
bisect_next "$@" ;;
--
1.5.3.4.213.g68ad5
^ permalink raw reply related
* [PATCH 7/7] Bisect: add "bisect dunno" to the documentation.
From: Christian Couder @ 2007-10-14 12:30 UTC (permalink / raw)
To: Junio Hamano, Johannes Schindelin; +Cc: git
Also fix "bisect bad" and "bisect good" short usage description.
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
---
Documentation/git-bisect.txt | 19 +++++++++++++++++--
1 files changed, 17 insertions(+), 2 deletions(-)
diff --git a/Documentation/git-bisect.txt b/Documentation/git-bisect.txt
index 1072fb8..2be2284 100644
--- a/Documentation/git-bisect.txt
+++ b/Documentation/git-bisect.txt
@@ -16,8 +16,9 @@ The command takes various subcommands, and different options depending
on the subcommand:
git bisect start [<bad> [<good>...]] [--] [<paths>...]
- git bisect bad <rev>
- git bisect good <rev>
+ git bisect bad [<rev>]
+ git bisect good [<rev>...]
+ git bisect dunno [<rev>...]
git bisect reset [<branch>]
git bisect visualize
git bisect replay <logfile>
@@ -134,6 +135,20 @@ $ git reset --hard HEAD~3 # try 3 revs before what
Then compile and test the one you chose to try. After that, tell
bisect what the result was as usual.
+Bisect dunno
+~~~~~~~~~~~~
+
+Instead of choosing by yourself a nearby commit, you may just want git
+to do it for you using:
+
+------------
+$ git bisect dunno # Current version cannot be tested
+------------
+
+But computing the commit to test may be slower afterwards and git may
+eventually not be able to tell the first bad among a bad and one or
+more dunno commits.
+
Cutting down bisection by giving more parameters to bisect start
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
1.5.3.4.213.g68ad5
^ permalink raw reply related
* Re: [PATCH] [BUG FIXED 2] git-add (-a|-u) and -n support
From: Michael Witten @ 2007-10-14 12:24 UTC (permalink / raw)
To: git
In-Reply-To: <0458D1DA-6261-4DA6-91B0-739F4D35AADF@mit.edu>
Sorry for the "spam"!
On 14 Oct 2007, at 6:26:28 AM, Michael Witten wrote:
> Hello,
>
> The git-add command doesn't handle -n when using -u.
>
> I fixed this and added -a for adding ALL files, not
> just those below the current directory (just like
> git-commit).
>
> The patch is below, but you can also download it from
> http://web.mit.edu/mfwitten/git/0001-git-add-now-understands-two-
> kinds-of-update.patch
>
Unfortunately, I left a second bug in place.
I was too excited about submitting a patch,
and too tired to get it right.
The following:
> + if (verbose)
> + printf("remove '%s'\n", path);
> + if (!show_only)
> + remove_file_from_cache(path);
Should be:
> + if (show_only || verbose)
> + printf("remove '%s'\n", path);
> + if (!show_only)
> + remove_file_from_cache(path);
The new patch is listed below:
(http://web.mit.edu/mfwitten/git/0001-git-add-now-understands-two-
kinds-of-update.patch)
From c3c2f07f3f94aa75d73fce0dfabc3958532f38c4 Mon Sep 17 00:00:00 2001
From: Michael Witten <mfwitten@mit.edu>
Date: Sun, 14 Oct 2007 06:13:20 -0400
Subject: [PATCH] git-add now understands two kinds of update:
-u: update as before
-a: update all as in a true 'git commit -a'
Also, -n works correctly now with the above options.
Signed-off-by: Michael Witten <mfwitten@mit.edu>
---
builtin-add.c | 69 +++++++++++++++++++++++++++++++++++++
+-------------------
1 files changed, 46 insertions(+), 23 deletions(-)
diff --git a/builtin-add.c b/builtin-add.c
index f9a6580..3c79a95 100644
--- a/builtin-add.c
+++ b/builtin-add.c
@@ -13,10 +13,11 @@
#include "commit.h"
#include "revision.h"
+enum update_type {NONE, ALL, CURRENT_DIRECTORY};
+
static const char builtin_add_usage[] =
"git-add [-n] [-v] [-f] [--interactive | -i] [-u] [--refresh] [--]
<filepattern>...";
-static int take_worktree_changes;
static const char *excludes_file;
static void prune_directory(struct dir_struct *dir, const char
**pathspec, int prefix)
@@ -83,40 +84,57 @@ static void fill_directory(struct dir_struct
*dir, const char **pathspec,
static void update_callback(struct diff_queue_struct *q,
struct diff_options *opt, void *cbdata)
{
- int i, verbose;
-
- verbose = *((int *)cbdata);
+ int i;
+
+ int* options = (int*)cbdata;
+ int verbose = options[0];
+ int show_only = options[1];
+
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
const char *path = p->one->path;
- switch (p->status) {
- default:
- die("unexpected diff status %c", p->status);
- case DIFF_STATUS_UNMERGED:
- case DIFF_STATUS_MODIFIED:
- case DIFF_STATUS_TYPE_CHANGED:
- add_file_to_cache(path, verbose);
- break;
- case DIFF_STATUS_DELETED:
- remove_file_from_cache(path);
- if (verbose)
- printf("remove '%s'\n", path);
- break;
+
+ switch (p->status) {
+ case DIFF_STATUS_UNMERGED:
+ case DIFF_STATUS_MODIFIED:
+ case DIFF_STATUS_TYPE_CHANGED:
+ if (show_only)
+ printf("add '%s'\n", path);
+ else
+ add_file_to_cache(path, verbose);
+ break;
+
+ case DIFF_STATUS_DELETED:
+ if (show_only || verbose)
+ printf("remove '%s'\n", path);
+ if (!show_only)
+ remove_file_from_cache(path);
+ break;
+
+ default:
+ die("unexpected diff status %c", p->status);
}
}
}
-static void update(int verbose, const char *prefix, const char **files)
+static void update(enum update_type type, int verbose, int show_only,
+ const char *prefix, const char **files)
{
struct rev_info rev;
+ int callback_options[] = {verbose, show_only};
+
init_revisions(&rev, prefix);
setup_revisions(0, NULL, &rev, NULL);
- rev.prune_data = get_pathspec(prefix, files);
+
+ rev.prune_data = type == ALL ? NULL : get_pathspec(prefix, files);
+
rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
rev.diffopt.format_callback = update_callback;
- rev.diffopt.format_callback_data = &verbose;
+ rev.diffopt.format_callback_data = callback_options;
+
if (read_cache() < 0)
die("index file corrupt");
+
run_diff_files(&rev, 0);
}
@@ -158,6 +176,7 @@ int cmd_add(int argc, const char **argv, const
char *prefix)
{
int i, newfd;
int verbose = 0, show_only = 0, ignored_too = 0, refresh_only = 0;
+ enum update_type update_type = NONE;
const char **pathspec;
struct dir_struct dir;
int add_interactive = 0;
@@ -201,8 +220,12 @@ int cmd_add(int argc, const char **argv, const
char *prefix)
verbose = 1;
continue;
}
+ if (!strcmp(arg, "-a")) {
+ update_type = ALL;
+ continue;
+ }
if (!strcmp(arg, "-u")) {
- take_worktree_changes = 1;
+ update_type = CURRENT_DIRECTORY;
continue;
}
if (!strcmp(arg, "--refresh")) {
@@ -212,8 +235,8 @@ int cmd_add(int argc, const char **argv, const
char *prefix)
usage(builtin_add_usage);
}
- if (take_worktree_changes) {
- update(verbose, prefix, argv + i);
+ if (update_type) {
+ update(update_type, verbose, show_only, prefix, argv + i);
goto finish;
}
--
1.5.3.4.207.g6d7480-dirty
^ permalink raw reply related
* Re: [PATCH 0/7] Bisect dunno
From: Wincent Colaiuta @ 2007-10-14 12:43 UTC (permalink / raw)
To: Christian Couder; +Cc: Junio Hamano, Johannes Schindelin, git
In-Reply-To: <20071014142826.8caa0a9f.chriscool@tuxfamily.org>
El 14/10/2007, a las 14:28, Christian Couder escribió:
> Here is my bisect dunno patch series again.
Good work on the series, Christian, but don't you think that
"unknown" would sound a little bit better than "dunno"? For people
who don't speak English as a second language "dunno" might not be
immediately clear.
Cheers,
Wincent
^ permalink raw reply
* Re: [PATCH v2] mergetool: support setting path to tool as config var mergetool.<tool>.path
From: Steffen Prohaska @ 2007-10-14 12:52 UTC (permalink / raw)
To: Theodore Tso; +Cc: Git Mailing List
In-Reply-To: <11919632613176-git-send-email-prohaska@zib.de>
On Oct 9, 2007, at 10:54 PM, Steffen Prohaska wrote:
> This commit adds a mechanism to provide absolute paths to the
> external programs called by 'git mergetool'. A path can be
> specified in the configuation variable mergetool.<tool>.path.
Any news on this patch?
Will you apply it (or recommend that Junio does)?
Steffen
^ permalink raw reply
* Re: [PATCH 0/7] Bisect dunno
From: Wincent Colaiuta @ 2007-10-14 12:59 UTC (permalink / raw)
To: Wincent Colaiuta; +Cc: Christian Couder, Junio Hamano, Johannes Schindelin, git
In-Reply-To: <F32B0EEF-496C-4D6D-BD9A-B6A0C04E0EE3@wincent.com>
El 14/10/2007, a las 14:43, Wincent Colaiuta escribió:
> El 14/10/2007, a las 14:28, Christian Couder escribió:
>
>> Here is my bisect dunno patch series again.
>
> Good work on the series, Christian, but don't you think that
> "unknown" would sound a little bit better than "dunno"? For people
> who don't speak English as a second language "dunno" might not be
> immediately clear.
Doh, I meant to say "people who don't speak English as a *first*
language".
Cheers,
Wincent
^ permalink raw reply
* Re: [PATCH 0/7] Bisect dunno
From: David Kastrup @ 2007-10-14 13:00 UTC (permalink / raw)
To: Wincent Colaiuta; +Cc: Christian Couder, Junio Hamano, Johannes Schindelin, git
In-Reply-To: <F32B0EEF-496C-4D6D-BD9A-B6A0C04E0EE3@wincent.com>
Wincent Colaiuta <win@wincent.com> writes:
> El 14/10/2007, a las 14:28, Christian Couder escribió:
>
>> Here is my bisect dunno patch series again.
>
> Good work on the series, Christian, but don't you think that
> "unknown" would sound a little bit better than "dunno"? For people
> who don't speak English as a second language "dunno" might not be
> immediately clear.
"undecided"?
--
David Kastrup, Kriemhildstr. 15, 44793 Bochum
^ permalink raw reply
* Re: [PATCH v2] mergetool: support setting path to tool as config var mergetool.<tool>.path
From: Theodore Tso @ 2007-10-14 13:02 UTC (permalink / raw)
To: Steffen Prohaska; +Cc: Git Mailing List
In-Reply-To: <06B63221-7F8E-42FF-959F-D83FBABA6790@zib.de>
On Sun, Oct 14, 2007 at 02:52:25PM +0200, Steffen Prohaska wrote:
>
>> This commit adds a mechanism to provide absolute paths to the
>> external programs called by 'git mergetool'. A path can be
>> specified in the configuation variable mergetool.<tool>.path.
>
> Any news on this patch?
> Will you apply it (or recommend that Junio does)?
Hmm, for some reason I never received the v2 version of the patch. I
see Johannes' comments to it, but not the original e-mail for some
reason. It doesn't seem to be in the spam filter, so I'm not sure
what happened.
Can you resend, please? Thanks!!
- Ted
^ permalink raw reply
* Re: [PATCH] [BUG FIXED 2] git-add (-a|-u) and -n support
From: Matthieu Moy @ 2007-10-14 13:25 UTC (permalink / raw)
To: Michael Witten; +Cc: git
In-Reply-To: <E857D120-787F-460B-A167-4B5F4BD2C3B5@mit.edu>
Michael Witten <mfwitten@MIT.EDU> writes:
> Subject: [PATCH] git-add now understands two kinds of update:
>
> -u: update as before
> -a: update all as in a true 'git commit -a'
I don't find the option set very intuitive. I'd prefer
- git add -u . => update the current directory as before
- git add -u => update all files from the root.
But your solution has the advantage of being backward compatible, so,
no strong opinion here.
(side note: also, while you're here, it would be nice to have a single
command to do "git add .; git add -u", i.e add all unknown files,
update all existing files, and actally remove all deleted files. In
one word, synchronize the index with the working tree completely.
Perhaps "-a" would be a good name for that, not sure)
> builtin-add.c | 69 +++++++++++++++++++++++++++++++++++++
> +-------------------
Your patch is whitespace-damaged. I don't know how to fix that for
Apple Mail, but git-send-email can help.
> static const char builtin_add_usage[] =
> "git-add [-n] [-v] [-f] [--interactive | -i] [-u] [--refresh] [--]
> <filepattern>...";
You should document -a here, and in Documentation/git-add.txt if you
introduce it.
--
Matthieu
^ permalink raw reply
* [PATCH] Simplify usage string printing
From: Jonas Fonseca @ 2007-10-14 14:01 UTC (permalink / raw)
To: Pierre Habouzit; +Cc: git, Junio C Hamano
In-Reply-To: <1192282153-26684-10-git-send-email-madcoder@debian.org>
Signed-off-by: Jonas Fonseca <fonseca@diku.dk>
---
builtin-branch.c | 1 -
builtin-update-ref.c | 1 -
parse-options.c | 2 +-
3 files changed, 1 insertions(+), 3 deletions(-)
Pierre Habouzit <madcoder@debian.org> wrote Sat, Oct 13, 2007:
> Signed-off-by: Pierre Habouzit <madcoder@debian.org>
> ---
> builtin-update-ref.c | 71 +++++++++++++++++++++-----------------------------
> 1 files changed, 30 insertions(+), 41 deletions(-)
>
> diff --git a/builtin-update-ref.c b/builtin-update-ref.c
> index fe1f74c..eafb642 100644
> --- a/builtin-update-ref.c
> +++ b/builtin-update-ref.c
> @@ -1,59 +1,48 @@
> #include "cache.h"
> #include "refs.h"
> #include "builtin.h"
> +#include "parse-options.h"
>
> -static const char git_update_ref_usage[] =
> -"git-update-ref [-m <reason>] (-d <refname> <value> | [--no-deref] <refname> <value> [<oldval>])";
> +static const char * const git_update_ref_usage[] = {
> + "",
> + "git-update-ref [options] -d <refname> <oldval>",
> + "git-update-ref [options] <refname> <newval> [<oldval>]",
> + NULL
> +};
How about something like this to get rid of these empty strings
that look strange?
> ./git update-ref -h
usage: git-update-ref [options] -d <refname> <oldval>
or: git-update-ref [options] <refname> <newval> [<oldval>]
-m <reason> reason of the update
-d deletes the reference
--no-deref update <refname> not the one it points to
diff --git a/builtin-branch.c b/builtin-branch.c
index fbf983e..d7c4657 100644
--- a/builtin-branch.c
+++ b/builtin-branch.c
@@ -14,7 +14,6 @@
#include "parse-options.h"
static const char * const builtin_branch_usage[] = {
- "",
"git-branch [options] [-r | -a]",
"git-branch [options] [-l] [-f] <branchname> [<start-point>]",
"git-branch [options] [-r] (-d | -D) <branchname>",
diff --git a/builtin-update-ref.c b/builtin-update-ref.c
index d66d9b5..0cd7817 100644
--- a/builtin-update-ref.c
+++ b/builtin-update-ref.c
@@ -4,7 +4,6 @@
#include "parse-options.h"
static const char * const git_update_ref_usage[] = {
- "",
"git-update-ref [options] -d <refname> <oldval>",
"git-update-ref [options] <refname> <newval> [<oldval>]",
NULL
diff --git a/parse-options.c b/parse-options.c
index c45bb9b..b1d9608 100644
--- a/parse-options.c
+++ b/parse-options.c
@@ -181,7 +181,7 @@ void usage_with_options(const char * const *usagestr,
{
fprintf(stderr, "usage: %s\n", *usagestr);
while (*++usagestr)
- fprintf(stderr, " %s\n", *usagestr);
+ fprintf(stderr, " or: %s\n", *usagestr);
if (opts->type != OPTION_GROUP)
fputc('\n', stderr);
--
1.5.3.4.1166.gf076
--
Jonas Fonseca
^ permalink raw reply related
* [PATCH] Update manpages to reflect new short and long option aliases
From: Jonas Fonseca @ 2007-10-14 14:10 UTC (permalink / raw)
To: Pierre Habouzit; +Cc: git, Junio C Hamano
In-Reply-To: <1192282153-26684-2-git-send-email-madcoder@debian.org>
Signed-off-by: Jonas Fonseca <fonseca@diku.dk>
---
Documentation/git-add.txt | 4 ++--
Documentation/git-branch.txt | 2 +-
Documentation/git-mv.txt | 2 +-
Documentation/git-rm.txt | 4 ++--
Documentation/git-symbolic-ref.txt | 2 +-
5 files changed, 7 insertions(+), 7 deletions(-)
Maybe this should wait, but it is just to document that this series (as
of the version in your git tree) also adds new option aliases.
BTW, I didn't bother to change the synopsis lines but maybe I should.
diff --git a/Documentation/git-add.txt b/Documentation/git-add.txt
index 2fe7355..963e1ab 100644
--- a/Documentation/git-add.txt
+++ b/Documentation/git-add.txt
@@ -50,10 +50,10 @@ OPTIONS
and `dir/file2`) can be given to add all files in the
directory, recursively.
--n::
+-n, \--dry-run::
Don't actually add the file(s), just show if they exist.
--v::
+-v, \--verbose::
Be verbose.
-f::
diff --git a/Documentation/git-branch.txt b/Documentation/git-branch.txt
index b7285bc..5e81aa4 100644
--- a/Documentation/git-branch.txt
+++ b/Documentation/git-branch.txt
@@ -85,7 +85,7 @@ OPTIONS
-a::
List both remote-tracking branches and local branches.
--v::
+-v, --verbose::
Show sha1 and commit subject line for each head.
--abbrev=<length>::
diff --git a/Documentation/git-mv.txt b/Documentation/git-mv.txt
index 2c9cf74..3b8ca76 100644
--- a/Documentation/git-mv.txt
+++ b/Documentation/git-mv.txt
@@ -34,7 +34,7 @@ OPTIONS
condition. An error happens when a source is neither existing nor
controlled by GIT, or when it would overwrite an existing
file unless '-f' is given.
--n::
+-n, \--dry-run::
Do nothing; only show what would happen
diff --git a/Documentation/git-rm.txt b/Documentation/git-rm.txt
index be61a82..48c1d97 100644
--- a/Documentation/git-rm.txt
+++ b/Documentation/git-rm.txt
@@ -30,7 +30,7 @@ OPTIONS
-f::
Override the up-to-date check.
--n::
+-n, \--dry-run::
Don't actually remove the file(s), just show if they exist in
the index.
@@ -51,7 +51,7 @@ OPTIONS
\--ignore-unmatch::
Exit with a zero status even if no files matched.
-\--quiet::
+-q, \--quiet::
git-rm normally outputs one line (in the form of an "rm" command)
for each file removed. This option suppresses that output.
diff --git a/Documentation/git-symbolic-ref.txt b/Documentation/git-symbolic-ref.txt
index a88f722..694caba 100644
--- a/Documentation/git-symbolic-ref.txt
+++ b/Documentation/git-symbolic-ref.txt
@@ -26,7 +26,7 @@ a regular file whose contents is `ref: refs/heads/master`.
OPTIONS
-------
--q::
+-q, --quiet::
Do not issue an error message if the <name> is not a
symbolic ref but a detached HEAD; instead exit with
non-zero status silently.
--
1.5.3.4.1166.gf076
--
Jonas Fonseca
^ permalink raw reply related
* git blame crashes with internal error
From: Björn Steinbrink @ 2007-10-14 14:36 UTC (permalink / raw)
To: gitster; +Cc: git
[-- Attachment #1: Type: text/plain, Size: 528 bytes --]
Hi Junio,
git blame just decided to crash on me, when I tried to use it while
resolving a merge conflict. Interesting is probably, that it crashes
when given the filename of a file that is not _directly_ affected by the
merge, but contains code that originates from a file that caused
conlicts.
Error message is:
fatal: internal error: ce_mode is 0
I tried all git releases from 1.5.3 to 1.5.3.4 as well as the current
master and all of them crashed. A small shell script to reproduce the
problem is attached.
Thanks,
Björn
[-- Attachment #2: testcase.sh --]
[-- Type: application/x-sh, Size: 842 bytes --]
^ permalink raw reply
* Re: git blame crashes with internal error
From: Andreas Ericsson @ 2007-10-14 14:51 UTC (permalink / raw)
To: Björn Steinbrink; +Cc: gitster, git
In-Reply-To: <20071014143628.GA22568@atjola.homenet>
Björn Steinbrink wrote:
>
> I tried all git releases from 1.5.3 to 1.5.3.4 as well as the current
> master and all of them crashed. A small shell script to reproduce the
> problem is attached.
>
Manual bisect? Ugh. This *is* the century of the competent developer
tools, you know... ;-)
--
Andreas Ericsson andreas.ericsson@op5.se
OP5 AB www.op5.se
Tel: +46 8-230225 Fax: +46 8-230231
^ permalink raw reply
* Re: git blame crashes with internal error
From: David Kastrup @ 2007-10-14 14:56 UTC (permalink / raw)
To: Andreas Ericsson; +Cc: Björn Steinbrink, gitster, git
In-Reply-To: <47122D02.9060204@op5.se>
Andreas Ericsson <ae@op5.se> writes:
> Björn Steinbrink wrote:
>>
>> I tried all git releases from 1.5.3 to 1.5.3.4 as well as the current
>> master and all of them crashed. A small shell script to reproduce the
>> problem is attached.
>>
>
> Manual bisect? Ugh. This *is* the century of the competent developer
> tools, you know... ;-)
It's not a "bisect" when it crashes in all versions.
--
David Kastrup, Kriemhildstr. 15, 44793 Bochum
^ permalink raw reply
* Re: [PATCH 0/7] Bisect dunno
From: Christian Couder @ 2007-10-14 15:09 UTC (permalink / raw)
To: David Kastrup; +Cc: Wincent Colaiuta, Junio Hamano, Johannes Schindelin, git
In-Reply-To: <854pgtonp5.fsf@lola.goethe.zz>
Le dimanche 14 octobre 2007, David Kastrup a écrit :
> Wincent Colaiuta <win@wincent.com> writes:
> > El 14/10/2007, a las 14:28, Christian Couder escribió:
> >> Here is my bisect dunno patch series again.
> >
> > Good work on the series, Christian, but don't you think that
> > "unknown" would sound a little bit better than "dunno"? For people
> > who don't speak English as a second language "dunno" might not be
> > immediately clear.
>
> "undecided"?
I choosed "dunno" because that was what Dscho suggested in this thread:
http://thread.gmane.org/gmane.comp.version-control.git/53584/focus=53595
It seems to me short and understandable at the same time.
More meaningfull would be "untestable" or "cannottest" or "canttest" but
it's much longer, while "good" and "bad" are short.
Christian.
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox