From: Junio C Hamano <gitster@pobox.com>
Date: Sun, 12 Apr 2009 23:46:42 +0000 (-0700)
Subject: Merge branch 'jk/show-upstream'
X-Git-Tag: v1.6.3-rc0~4
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/3e52effcf6efa9ef27b3d67d13f535a0381e3bf2?ds=inline;hp=-c

Merge branch 'jk/show-upstream'

* jk/show-upstream:
branch: show upstream branch when double verbose
make get_short_ref a public function
for-each-ref: add "upstream" format field
for-each-ref: refactor refname handling
for-each-ref: refactor get_short_ref function
---

3e52effcf6efa9ef27b3d67d13f535a0381e3bf2
diff --combined refs.c
index 9ccaf40172,1e5e7b4ad9..82afb87684
--- a/refs.c
+++ b/refs.c
@@@ -647,24 -647,19 +647,24 @@@ int for_each_ref(each_ref_fn fn, void *
  	return do_for_each_ref("refs/", fn, 0, 0, cb_data);
  }
  
 +int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
 +{
 +	return do_for_each_ref(prefix, fn, strlen(prefix), 0, cb_data);
 +}
 +
  int for_each_tag_ref(each_ref_fn fn, void *cb_data)
  {
 -	return do_for_each_ref("refs/tags/", fn, 10, 0, cb_data);
 +	return for_each_ref_in("refs/tags/", fn, cb_data);
  }
  
  int for_each_branch_ref(each_ref_fn fn, void *cb_data)
  {
 -	return do_for_each_ref("refs/heads/", fn, 11, 0, cb_data);
 +	return for_each_ref_in("refs/heads/", fn, cb_data);
  }
  
  int for_each_remote_ref(each_ref_fn fn, void *cb_data)
  {
 -	return do_for_each_ref("refs/remotes/", fn, 13, 0, cb_data);
 +	return for_each_ref_in("refs/remotes/", fn, cb_data);
  }
  
  int for_each_rawref(each_ref_fn fn, void *cb_data)
@@@ -1657,3 -1652,102 +1657,102 @@@ struct ref *find_ref_by_name(const stru
  			return (struct ref *)list;
  	return NULL;
  }
+ 
+ /*
+  * generate a format suitable for scanf from a ref_rev_parse_rules
+  * rule, that is replace the "%.*s" spec with a "%s" spec
+  */
+ static void gen_scanf_fmt(char *scanf_fmt, const char *rule)
+ {
+ 	char *spec;
+ 
+ 	spec = strstr(rule, "%.*s");
+ 	if (!spec || strstr(spec + 4, "%.*s"))
+ 		die("invalid rule in ref_rev_parse_rules: %s", rule);
+ 
+ 	/* copy all until spec */
+ 	strncpy(scanf_fmt, rule, spec - rule);
+ 	scanf_fmt[spec - rule] = '\0';
+ 	/* copy new spec */
+ 	strcat(scanf_fmt, "%s");
+ 	/* copy remaining rule */
+ 	strcat(scanf_fmt, spec + 4);
+ 
+ 	return;
+ }
+ 
+ char *shorten_unambiguous_ref(const char *ref)
+ {
+ 	int i;
+ 	static char **scanf_fmts;
+ 	static int nr_rules;
+ 	char *short_name;
+ 
+ 	/* pre generate scanf formats from ref_rev_parse_rules[] */
+ 	if (!nr_rules) {
+ 		size_t total_len = 0;
+ 
+ 		/* the rule list is NULL terminated, count them first */
+ 		for (; ref_rev_parse_rules[nr_rules]; nr_rules++)
+ 			/* no +1 because strlen("%s") < strlen("%.*s") */
+ 			total_len += strlen(ref_rev_parse_rules[nr_rules]);
+ 
+ 		scanf_fmts = xmalloc(nr_rules * sizeof(char *) + total_len);
+ 
+ 		total_len = 0;
+ 		for (i = 0; i < nr_rules; i++) {
+ 			scanf_fmts[i] = (char *)&scanf_fmts[nr_rules]
+ 					+ total_len;
+ 			gen_scanf_fmt(scanf_fmts[i], ref_rev_parse_rules[i]);
+ 			total_len += strlen(ref_rev_parse_rules[i]);
+ 		}
+ 	}
+ 
+ 	/* bail out if there are no rules */
+ 	if (!nr_rules)
+ 		return xstrdup(ref);
+ 
+ 	/* buffer for scanf result, at most ref must fit */
+ 	short_name = xstrdup(ref);
+ 
+ 	/* skip first rule, it will always match */
+ 	for (i = nr_rules - 1; i > 0 ; --i) {
+ 		int j;
+ 		int short_name_len;
+ 
+ 		if (1 != sscanf(ref, scanf_fmts[i], short_name))
+ 			continue;
+ 
+ 		short_name_len = strlen(short_name);
+ 
+ 		/*
+ 		 * check if the short name resolves to a valid ref,
+ 		 * but use only rules prior to the matched one
+ 		 */
+ 		for (j = 0; j < i; j++) {
+ 			const char *rule = ref_rev_parse_rules[j];
+ 			unsigned char short_objectname[20];
+ 			char refname[PATH_MAX];
+ 
+ 			/*
+ 			 * the short name is ambiguous, if it resolves
+ 			 * (with this previous rule) to a valid ref
+ 			 * read_ref() returns 0 on success
+ 			 */
+ 			mksnpath(refname, sizeof(refname),
+ 				 rule, short_name_len, short_name);
+ 			if (!read_ref(refname, short_objectname))
+ 				break;
+ 		}
+ 
+ 		/*
+ 		 * short name is non-ambiguous if all previous rules
+ 		 * haven't resolved to a valid ref
+ 		 */
+ 		if (j == i)
+ 			return short_name;
+ 	}
+ 
+ 	free(short_name);
+ 	return xstrdup(ref);
+ }
diff --combined refs.h
index 2f6a8af608,2d0f961c7c..50abbbb2aa
--- a/refs.h
+++ b/refs.h
@@@ -20,7 -20,6 +20,7 @@@ struct ref_lock 
  typedef int each_ref_fn(const char *refname, const unsigned char *sha1, int flags, void *cb_data);
  extern int head_ref(each_ref_fn, void *);
  extern int for_each_ref(each_ref_fn, void *);
 +extern int for_each_ref_in(const char *, each_ref_fn, void *);
  extern int for_each_tag_ref(each_ref_fn, void *);
  extern int for_each_branch_ref(each_ref_fn, void *);
  extern int for_each_remote_ref(each_ref_fn, void *);
@@@ -81,6 -80,7 +81,7 @@@ extern int for_each_reflog(each_ref_fn
  extern int check_ref_format(const char *target);
  
  extern const char *prettify_ref(const struct ref *ref);
+ extern char *shorten_unambiguous_ref(const char *ref);
  
  /** rename ref, return 0 on success **/
  extern int rename_ref(const char *oldref, const char *newref, const char *logmsg);