Peter Hagervall | baffc0e | 2007-07-15 01:14:45 +0200 | [diff] [blame] | 1 | #include "builtin.h" |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 2 | #include "cache.h" |
| 3 | #include "refs.h" |
| 4 | #include "object.h" |
| 5 | #include "tag.h" |
Johannes Schindelin | c455c87 | 2008-07-21 19:03:49 +0100 | [diff] [blame] | 6 | #include "string-list.h" |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 7 | #include "parse-options.h" |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 8 | |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 9 | static const char * const show_ref_usage[] = { |
Jonathan Nieder | e62b393 | 2009-11-09 09:04:46 -0600 | [diff] [blame] | 10 | "git show-ref [-q|--quiet] [--verify] [--head] [-d|--dereference] [-s|--hash[=<n>]] [--abbrev[=<n>]] [--tags] [--heads] [--] [pattern*] ", |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 11 | "git show-ref --exclude-existing[=pattern] < ref-list", |
| 12 | NULL |
| 13 | }; |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 14 | |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 15 | static int deref_tags, show_head, tags_only, heads_only, found_match, verify, |
| 16 | quiet, hash_only, abbrev, exclude_arg; |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 17 | static const char **pattern; |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 18 | static const char *exclude_existing_arg; |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 19 | |
Junio C Hamano | 64fe031 | 2006-12-17 19:27:49 -0800 | [diff] [blame] | 20 | static void show_one(const char *refname, const unsigned char *sha1) |
| 21 | { |
| 22 | const char *hex = find_unique_abbrev(sha1, abbrev); |
| 23 | if (hash_only) |
| 24 | printf("%s\n", hex); |
| 25 | else |
| 26 | printf("%s %s\n", hex, refname); |
| 27 | } |
| 28 | |
Junio C Hamano | eaf12a8 | 2006-09-21 00:40:28 -0700 | [diff] [blame] | 29 | static int show_ref(const char *refname, const unsigned char *sha1, int flag, void *cbdata) |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 30 | { |
| 31 | struct object *obj; |
Junio C Hamano | 2eaf222 | 2006-10-01 00:27:27 -0700 | [diff] [blame] | 32 | const char *hex; |
Junio C Hamano | cf0adba | 2006-11-19 13:22:44 -0800 | [diff] [blame] | 33 | unsigned char peeled[20]; |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 34 | |
| 35 | if (tags_only || heads_only) { |
| 36 | int match; |
| 37 | |
Junio C Hamano | cc44c76 | 2007-02-20 01:53:29 -0800 | [diff] [blame] | 38 | match = heads_only && !prefixcmp(refname, "refs/heads/"); |
| 39 | match |= tags_only && !prefixcmp(refname, "refs/tags/"); |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 40 | if (!match) |
| 41 | return 0; |
| 42 | } |
| 43 | if (pattern) { |
| 44 | int reflen = strlen(refname); |
| 45 | const char **p = pattern, *m; |
| 46 | while ((m = *p++) != NULL) { |
| 47 | int len = strlen(m); |
| 48 | if (len > reflen) |
| 49 | continue; |
| 50 | if (memcmp(m, refname + reflen - len, len)) |
| 51 | continue; |
| 52 | if (len == reflen) |
| 53 | goto match; |
| 54 | /* "--verify" requires an exact match */ |
| 55 | if (verify) |
| 56 | continue; |
| 57 | if (refname[reflen - len - 1] == '/') |
| 58 | goto match; |
| 59 | } |
| 60 | return 0; |
| 61 | } |
| 62 | |
| 63 | match: |
| 64 | found_match++; |
Junio C Hamano | cf0adba | 2006-11-19 13:22:44 -0800 | [diff] [blame] | 65 | |
| 66 | /* This changes the semantics slightly that even under quiet we |
| 67 | * detect and return error if the repository is corrupt and |
| 68 | * ref points at a nonexistent object. |
| 69 | */ |
| 70 | if (!has_sha1_file(sha1)) |
Junio C Hamano | 7e44c93 | 2008-08-31 09:39:19 -0700 | [diff] [blame] | 71 | die("git show-ref: bad ref %s (%s)", refname, |
Junio C Hamano | cf0adba | 2006-11-19 13:22:44 -0800 | [diff] [blame] | 72 | sha1_to_hex(sha1)); |
| 73 | |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 74 | if (quiet) |
| 75 | return 0; |
Junio C Hamano | 2eaf222 | 2006-10-01 00:27:27 -0700 | [diff] [blame] | 76 | |
Junio C Hamano | 64fe031 | 2006-12-17 19:27:49 -0800 | [diff] [blame] | 77 | show_one(refname, sha1); |
Junio C Hamano | cf0adba | 2006-11-19 13:22:44 -0800 | [diff] [blame] | 78 | |
| 79 | if (!deref_tags) |
| 80 | return 0; |
| 81 | |
| 82 | if ((flag & REF_ISPACKED) && !peel_ref(refname, peeled)) { |
Junio C Hamano | f4204ab | 2006-11-21 23:36:35 -0800 | [diff] [blame] | 83 | if (!is_null_sha1(peeled)) { |
| 84 | hex = find_unique_abbrev(peeled, abbrev); |
| 85 | printf("%s %s^{}\n", hex, refname); |
| 86 | } |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 87 | } |
Junio C Hamano | cf0adba | 2006-11-19 13:22:44 -0800 | [diff] [blame] | 88 | else { |
| 89 | obj = parse_object(sha1); |
| 90 | if (!obj) |
Junio C Hamano | 7e44c93 | 2008-08-31 09:39:19 -0700 | [diff] [blame] | 91 | die("git show-ref: bad ref %s (%s)", refname, |
Junio C Hamano | cf0adba | 2006-11-19 13:22:44 -0800 | [diff] [blame] | 92 | sha1_to_hex(sha1)); |
| 93 | if (obj->type == OBJ_TAG) { |
| 94 | obj = deref_tag(obj, refname, 0); |
Martin Koegler | affeef1 | 2008-02-18 08:31:54 +0100 | [diff] [blame] | 95 | if (!obj) |
Junio C Hamano | 7e44c93 | 2008-08-31 09:39:19 -0700 | [diff] [blame] | 96 | die("git show-ref: bad tag at ref %s (%s)", refname, |
Martin Koegler | affeef1 | 2008-02-18 08:31:54 +0100 | [diff] [blame] | 97 | sha1_to_hex(sha1)); |
Junio C Hamano | cf0adba | 2006-11-19 13:22:44 -0800 | [diff] [blame] | 98 | hex = find_unique_abbrev(obj->sha1, abbrev); |
| 99 | printf("%s %s^{}\n", hex, refname); |
| 100 | } |
| 101 | } |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 102 | return 0; |
| 103 | } |
| 104 | |
Junio C Hamano | ed9f7c9 | 2006-12-17 17:57:19 -0800 | [diff] [blame] | 105 | static int add_existing(const char *refname, const unsigned char *sha1, int flag, void *cbdata) |
| 106 | { |
Johannes Schindelin | c455c87 | 2008-07-21 19:03:49 +0100 | [diff] [blame] | 107 | struct string_list *list = (struct string_list *)cbdata; |
Julian Phillips | 78a395d | 2010-06-26 00:41:35 +0100 | [diff] [blame] | 108 | string_list_insert(list, refname); |
Junio C Hamano | ed9f7c9 | 2006-12-17 17:57:19 -0800 | [diff] [blame] | 109 | return 0; |
| 110 | } |
| 111 | |
| 112 | /* |
| 113 | * read "^(?:<anything>\s)?<refname>(?:\^\{\})?$" from the standard input, |
| 114 | * and |
| 115 | * (1) strip "^{}" at the end of line if any; |
| 116 | * (2) ignore if match is provided and does not head-match refname; |
| 117 | * (3) warn if refname is not a well-formed refname and skip; |
| 118 | * (4) ignore if refname is a ref that exists in the local repository; |
| 119 | * (5) otherwise output the line. |
| 120 | */ |
| 121 | static int exclude_existing(const char *match) |
| 122 | { |
Thiago Farina | 183113a | 2010-07-04 16:46:19 -0300 | [diff] [blame] | 123 | static struct string_list existing_refs = STRING_LIST_INIT_NODUP; |
Junio C Hamano | ed9f7c9 | 2006-12-17 17:57:19 -0800 | [diff] [blame] | 124 | char buf[1024]; |
| 125 | int matchlen = match ? strlen(match) : 0; |
| 126 | |
| 127 | for_each_ref(add_existing, &existing_refs); |
| 128 | while (fgets(buf, sizeof(buf), stdin)) { |
Junio C Hamano | ed9f7c9 | 2006-12-17 17:57:19 -0800 | [diff] [blame] | 129 | char *ref; |
Junio C Hamano | d8285af | 2006-12-18 13:33:47 -0800 | [diff] [blame] | 130 | int len = strlen(buf); |
| 131 | |
Junio C Hamano | ed9f7c9 | 2006-12-17 17:57:19 -0800 | [diff] [blame] | 132 | if (len > 0 && buf[len - 1] == '\n') |
| 133 | buf[--len] = '\0'; |
Junio C Hamano | d8285af | 2006-12-18 13:33:47 -0800 | [diff] [blame] | 134 | if (3 <= len && !strcmp(buf + len - 3, "^{}")) { |
Junio C Hamano | ed9f7c9 | 2006-12-17 17:57:19 -0800 | [diff] [blame] | 135 | len -= 3; |
| 136 | buf[len] = '\0'; |
| 137 | } |
| 138 | for (ref = buf + len; buf < ref; ref--) |
| 139 | if (isspace(ref[-1])) |
| 140 | break; |
| 141 | if (match) { |
| 142 | int reflen = buf + len - ref; |
| 143 | if (reflen < matchlen) |
| 144 | continue; |
| 145 | if (strncmp(ref, match, matchlen)) |
| 146 | continue; |
| 147 | } |
Michael Haggerty | 8d9c501 | 2011-09-15 23:10:25 +0200 | [diff] [blame] | 148 | if (check_refname_format(ref, 0)) { |
Miklos Vajna | 5620e77 | 2009-03-24 02:09:16 +0100 | [diff] [blame] | 149 | warning("ref '%s' ignored", ref); |
Junio C Hamano | ed9f7c9 | 2006-12-17 17:57:19 -0800 | [diff] [blame] | 150 | continue; |
| 151 | } |
Johannes Schindelin | c455c87 | 2008-07-21 19:03:49 +0100 | [diff] [blame] | 152 | if (!string_list_has_string(&existing_refs, ref)) { |
Junio C Hamano | ed9f7c9 | 2006-12-17 17:57:19 -0800 | [diff] [blame] | 153 | printf("%s\n", buf); |
| 154 | } |
| 155 | } |
| 156 | return 0; |
| 157 | } |
| 158 | |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 159 | static int hash_callback(const struct option *opt, const char *arg, int unset) |
| 160 | { |
| 161 | hash_only = 1; |
| 162 | /* Use full length SHA1 if no argument */ |
| 163 | if (!arg) |
| 164 | return 0; |
| 165 | return parse_opt_abbrev_cb(opt, arg, unset); |
| 166 | } |
| 167 | |
| 168 | static int exclude_existing_callback(const struct option *opt, const char *arg, |
| 169 | int unset) |
| 170 | { |
| 171 | exclude_arg = 1; |
| 172 | *(const char **)opt->value = arg; |
| 173 | return 0; |
| 174 | } |
| 175 | |
| 176 | static int help_callback(const struct option *opt, const char *arg, int unset) |
| 177 | { |
| 178 | return -1; |
| 179 | } |
| 180 | |
| 181 | static const struct option show_ref_options[] = { |
| 182 | OPT_BOOLEAN(0, "tags", &tags_only, "only show tags (can be combined with heads)"), |
| 183 | OPT_BOOLEAN(0, "heads", &heads_only, "only show heads (can be combined with tags)"), |
| 184 | OPT_BOOLEAN(0, "verify", &verify, "stricter reference checking, " |
| 185 | "requires exact ref path"), |
Jonathan Nieder | e62b393 | 2009-11-09 09:04:46 -0600 | [diff] [blame] | 186 | { OPTION_BOOLEAN, 'h', NULL, &show_head, NULL, |
| 187 | "show the HEAD reference", |
| 188 | PARSE_OPT_NOARG | PARSE_OPT_HIDDEN }, |
| 189 | OPT_BOOLEAN(0, "head", &show_head, "show the HEAD reference"), |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 190 | OPT_BOOLEAN('d', "dereference", &deref_tags, |
| 191 | "dereference tags into object IDs"), |
| 192 | { OPTION_CALLBACK, 's', "hash", &abbrev, "n", |
| 193 | "only show SHA1 hash using <n> digits", |
| 194 | PARSE_OPT_OPTARG, &hash_callback }, |
| 195 | OPT__ABBREV(&abbrev), |
Jonathan Nieder | 8c83968 | 2010-11-08 13:54:48 -0600 | [diff] [blame] | 196 | OPT__QUIET(&quiet, |
| 197 | "do not print results to stdout (useful with --verify)"), |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 198 | { OPTION_CALLBACK, 0, "exclude-existing", &exclude_existing_arg, |
| 199 | "pattern", "show refs from stdin that aren't in local repository", |
| 200 | PARSE_OPT_OPTARG | PARSE_OPT_NONEG, exclude_existing_callback }, |
| 201 | { OPTION_CALLBACK, 0, "help-all", NULL, NULL, "show usage", |
| 202 | PARSE_OPT_HIDDEN | PARSE_OPT_NOARG, help_callback }, |
| 203 | OPT_END() |
| 204 | }; |
| 205 | |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 206 | int cmd_show_ref(int argc, const char **argv, const char *prefix) |
| 207 | { |
Jonathan Nieder | e62b393 | 2009-11-09 09:04:46 -0600 | [diff] [blame] | 208 | if (argc == 2 && !strcmp(argv[1], "-h")) |
| 209 | usage_with_options(show_ref_usage, show_ref_options); |
| 210 | |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 211 | argc = parse_options(argc, argv, prefix, show_ref_options, |
| 212 | show_ref_usage, PARSE_OPT_NO_INTERNAL_HELP); |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 213 | |
Stephen Boyd | 69932bc | 2009-06-20 21:40:46 -0700 | [diff] [blame] | 214 | if (exclude_arg) |
| 215 | return exclude_existing(exclude_existing_arg); |
| 216 | |
| 217 | pattern = argv; |
| 218 | if (!*pattern) |
| 219 | pattern = NULL; |
Junio C Hamano | 26cdd1e | 2006-12-17 18:08:52 -0800 | [diff] [blame] | 220 | |
| 221 | if (verify) { |
Dmitry V. Levin | 8ab40a2 | 2007-02-23 20:12:33 +0300 | [diff] [blame] | 222 | if (!pattern) |
| 223 | die("--verify requires a reference"); |
Junio C Hamano | 26cdd1e | 2006-12-17 18:08:52 -0800 | [diff] [blame] | 224 | while (*pattern) { |
Dmitry V. Levin | 8ab40a2 | 2007-02-23 20:12:33 +0300 | [diff] [blame] | 225 | unsigned char sha1[20]; |
| 226 | |
Junio C Hamano | cc44c76 | 2007-02-20 01:53:29 -0800 | [diff] [blame] | 227 | if (!prefixcmp(*pattern, "refs/") && |
Junio C Hamano | 64fe031 | 2006-12-17 19:27:49 -0800 | [diff] [blame] | 228 | resolve_ref(*pattern, sha1, 1, NULL)) { |
Junio C Hamano | dd91429 | 2006-12-17 18:53:24 -0800 | [diff] [blame] | 229 | if (!quiet) |
Junio C Hamano | 64fe031 | 2006-12-17 19:27:49 -0800 | [diff] [blame] | 230 | show_one(*pattern, sha1); |
Junio C Hamano | dd91429 | 2006-12-17 18:53:24 -0800 | [diff] [blame] | 231 | } |
Junio C Hamano | 26cdd1e | 2006-12-17 18:08:52 -0800 | [diff] [blame] | 232 | else if (!quiet) |
| 233 | die("'%s' - not a valid ref", *pattern); |
| 234 | else |
| 235 | return 1; |
| 236 | pattern++; |
| 237 | } |
| 238 | return 0; |
| 239 | } |
| 240 | |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 241 | if (show_head) |
Junio C Hamano | eaf12a8 | 2006-09-21 00:40:28 -0700 | [diff] [blame] | 242 | head_ref(show_ref, NULL); |
| 243 | for_each_ref(show_ref, NULL); |
Linus Torvalds | 358ddb6 | 2006-09-15 11:19:32 -0700 | [diff] [blame] | 244 | if (!found_match) { |
| 245 | if (verify && !quiet) |
| 246 | die("No match"); |
| 247 | return 1; |
| 248 | } |
| 249 | return 0; |
| 250 | } |