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