mirrors/git
1
0
Fork 0
mirror of https://github.com/git/git.git synced 2024-10-31 14:27:54 +01:00
Code Activity

git-fetch: more terse fetch output

Browse source 
This makes the fetch output much more terse and prettier on a 80 column
display, based on a consensus reached on the mailing list.  Here's an
example output:

Receiving objects: 100% (5439/5439), 1.60 MiB | 636 KiB/s, done.
Resolving deltas: 100% (4604/4604), done.
From git://git.kernel.org/pub/scm/git/git
 ! [rejected]        html -> origin/html  (non fast forward)
   136e631..f45e867  maint -> origin/maint  (fast forward)
   9850e2e..44dd7e0  man -> origin/man  (fast forward)
   3e4bb08..e3d6d56  master -> origin/master  (fast forward)
   fa3665c..536f64a  next -> origin/next  (fast forward)
 + 4f6d9d6...768326f pu -> origin/pu  (forced update)
 * [new branch]      todo -> origin/todo

Some portions of this patch have been extracted from earlier proposals
by Jeff King and Shawn Pearce.

Signed-off-by: Nicolas Pitre <nico@cam.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Nicolas Pitre 2007-11-03 01:32:48 -04:00 committed by Junio C Hamano
parent e3d6d56f1c
commit 165f390250
1 changed files with 60 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

114
builtin-fetch.c
View file

@ -131,12 +131,6 @@ static struct ref *get_ref_map(struct transport *transport,
return ref_map; return ref_map;
} }
static void show_new(enum object_type type, unsigned char *sha1_new)
{
fprintf(stderr, " %s: %s\n", typename(type),
find_unique_abbrev(sha1_new, DEFAULT_ABBREV));
}
static int s_update_ref(const char *action, static int s_update_ref(const char *action,
struct ref *ref, struct ref *ref,
int check_old) int check_old)
@ -157,34 +151,38 @@ static int s_update_ref(const char *action,
return 0; return 0;
} }
#define SUMMARY_WIDTH (2 * DEFAULT_ABBREV + 3)
static int update_local_ref(struct ref *ref, static int update_local_ref(struct ref *ref,
const char *note, const char *remote,
int verbose) int verbose,
char *display)
{ {
char oldh[41], newh[41];
struct commit *current = NULL, *updated; struct commit *current = NULL, *updated;
enum object_type type; enum object_type type;
struct branch *current_branch = branch_get(NULL); struct branch *current_branch = branch_get(NULL);
const char *pretty_ref = ref->name + (
!prefixcmp(ref->name, "refs/heads/") ? 11 :
!prefixcmp(ref->name, "refs/tags/") ? 10 :
!prefixcmp(ref->name, "refs/remotes/") ? 13 :
0);
*display = 0;
type = sha1_object_info(ref->new_sha1, NULL); type = sha1_object_info(ref->new_sha1, NULL);
if (type < 0) if (type < 0)
die("object %s not found", sha1_to_hex(ref->new_sha1)); die("object %s not found", sha1_to_hex(ref->new_sha1));
if (!*ref->name) { if (!*ref->name) {
/* Not storing */ /* Not storing */
if (verbose) { if (verbose)
fprintf(stderr, "* fetched %s\n", note); sprintf(display, "* branch %s -> FETCH_HEAD", remote);
show_new(type, ref->new_sha1);
}
return 0; return 0;
} }
if (!hashcmp(ref->old_sha1, ref->new_sha1)) { if (!hashcmp(ref->old_sha1, ref->new_sha1)) {
if (verbose) { if (verbose)
fprintf(stderr, "* %s: same as %s\n", sprintf(display, "= %-*s %s -> %s", SUMMARY_WIDTH,
ref->name, note); "[up to date]", remote, pretty_ref);
show_new(type, ref->new_sha1);
}
return 0; return 0;
} }
@ -196,63 +194,65 @@ static int update_local_ref(struct ref *ref,
* If this is the head, and it's not okay to update * If this is the head, and it's not okay to update
* the head, and the old value of the head isn't empty... * the head, and the old value of the head isn't empty...
*/ */
fprintf(stderr, sprintf(display, "! %-*s %s -> %s (can't fetch in current branch)",
" * %s: Cannot fetch into the current branch.\n", SUMMARY_WIDTH, "[rejected]", remote, pretty_ref);
ref->name);
return 1; return 1;
} }
if (!is_null_sha1(ref->old_sha1) && if (!is_null_sha1(ref->old_sha1) &&
!prefixcmp(ref->name, "refs/tags/")) { !prefixcmp(ref->name, "refs/tags/")) {
fprintf(stderr, "* %s: updating with %s\n", sprintf(display, "- %-*s %s -> %s",
ref->name, note); SUMMARY_WIDTH, "[tag update]", remote, pretty_ref);
show_new(type, ref->new_sha1);
return s_update_ref("updating tag", ref, 0); return s_update_ref("updating tag", ref, 0);
} }
current = lookup_commit_reference_gently(ref->old_sha1, 1); current = lookup_commit_reference_gently(ref->old_sha1, 1);
updated = lookup_commit_reference_gently(ref->new_sha1, 1); updated = lookup_commit_reference_gently(ref->new_sha1, 1);
if (!current || !updated) { if (!current || !updated) {
char *msg; const char *msg;
if (!strncmp(ref->name, "refs/tags/", 10)) const char *what;
if (!strncmp(ref->name, "refs/tags/", 10)) {
msg = "storing tag"; msg = "storing tag";
else what = "[new tag]";
}
else {
msg = "storing head"; msg = "storing head";
fprintf(stderr, "* %s: storing %s\n", what = "[new branch]";
ref->name, note); }
show_new(type, ref->new_sha1);
sprintf(display, "* %-*s %s -> %s",
SUMMARY_WIDTH, what, remote, pretty_ref);
return s_update_ref(msg, ref, 0); return s_update_ref(msg, ref, 0);
} }
strcpy(oldh, find_unique_abbrev(current->object.sha1, DEFAULT_ABBREV));
strcpy(newh, find_unique_abbrev(ref->new_sha1, DEFAULT_ABBREV));
if (in_merge_bases(current, &updated, 1)) { if (in_merge_bases(current, &updated, 1)) {
fprintf(stderr, "* %s: fast forward to %s\n", char quickref[83];
ref->name, note); strcpy(quickref, find_unique_abbrev(current->object.sha1, DEFAULT_ABBREV));
fprintf(stderr, " old..new: %s..%s\n", oldh, newh); strcat(quickref, "..");
strcat(quickref, find_unique_abbrev(ref->new_sha1, DEFAULT_ABBREV));
sprintf(display, " %-*s %s -> %s (fast forward)",
SUMMARY_WIDTH, quickref, remote, pretty_ref);
return s_update_ref("fast forward", ref, 1); return s_update_ref("fast forward", ref, 1);
} } else if (force || ref->force) {
if (!force && !ref->force) { char quickref[84];
fprintf(stderr, strcpy(quickref, find_unique_abbrev(current->object.sha1, DEFAULT_ABBREV));
"* %s: not updating to non-fast forward %s\n", strcat(quickref, "...");
ref->name, note); strcat(quickref, find_unique_abbrev(ref->new_sha1, DEFAULT_ABBREV));
fprintf(stderr, sprintf(display, "+ %-*s %s -> %s (forced update)",
" old...new: %s...%s\n", oldh, newh); SUMMARY_WIDTH, quickref, remote, pretty_ref);
return s_update_ref("forced-update", ref, 1);
} else {
sprintf(display, "! %-*s %s -> %s (non fast forward)",
SUMMARY_WIDTH, "[rejected]", remote, pretty_ref);
return 1; return 1;
} }
fprintf(stderr,
"* %s: forcing update to non-fast forward %s\n",
ref->name, note);
fprintf(stderr, " old...new: %s...%s\n", oldh, newh);
return s_update_ref("forced-update", ref, 1);
} }
static void store_updated_refs(const char *url, struct ref *ref_map) static void store_updated_refs(const char *url, struct ref *ref_map)
{ {
FILE *fp; FILE *fp;
struct commit *commit; struct commit *commit;
int url_len, i, note_len; int url_len, i, note_len, shown_url = 0;
char note[1024]; char note[1024];
const char *what, *kind; const char *what, *kind;
struct ref *rm; struct ref *rm;
@ -315,8 +315,17 @@ static void store_updated_refs(const char *url, struct ref *ref_map)
rm->merge ? "" : "not-for-merge", rm->merge ? "" : "not-for-merge",
note); note);
if (ref) if (ref) {
update_local_ref(ref, note, verbose); update_local_ref(ref, what, verbose, note);
if (*note) {
if (!shown_url) {
fprintf(stderr, "From %.*s\n",
url_len, url);
shown_url = 1;
}
fprintf(stderr, " %s\n", note);
}
}
} }
fclose(fp); fclose(fp);
} }
@ -376,9 +385,6 @@ static struct ref *find_non_local_tags(struct transport *transport,
if (!path_list_has_path(&existing_refs, ref_name) && if (!path_list_has_path(&existing_refs, ref_name) &&
!path_list_has_path(&new_refs, ref_name) && !path_list_has_path(&new_refs, ref_name) &&
lookup_object(ref->old_sha1)) { lookup_object(ref->old_sha1)) {
fprintf(stderr, "Auto-following %s\n",
ref_name);
path_list_insert(ref_name, &new_refs); path_list_insert(ref_name, &new_refs);
rm = alloc_ref(strlen(ref_name) + 1); rm = alloc_ref(strlen(ref_name) + 1);