src/refdb.c

   1 /* Copyright (c) 2006-2014 Jonas Fonseca <jonas.fonseca@gmail.com>
   2  *
   3  * This program is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU General Public License as
   5  * published by the Free Software Foundation; either version 2 of
   6  * the License, or (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include "tig/tig.h"
  15 #include "tig/argv.h"
  16 #include "tig/io.h"
  17 #include "tig/watch.h"
  18 #include "tig/options.h"
  19 #include "tig/repo.h"
  20 #include "tig/refdb.h"
  21
  22 static struct ref **refs = NULL;
  23 static size_t refs_size = 0;
  24 static struct ref *refs_head = NULL;
  25
  26 static struct ref_list **ref_lists = NULL;
  27 static size_t ref_lists_size = 0;
  28
  29 DEFINE_ALLOCATOR(realloc_refs, struct ref *, 256)
  30 DEFINE_ALLOCATOR(realloc_refs_list, struct ref *, 8)
  31 DEFINE_ALLOCATOR(realloc_ref_lists, struct ref_list *, 8)
  32
  33 static int
  34 compare_refs(const void *ref1_, const void *ref2_)
  35 {
  36         const struct ref *ref1 = *(const struct ref **)ref1_;
  37         const struct ref *ref2 = *(const struct ref **)ref2_;
  38
  39         return ref_compare(ref1, ref2);
  40 }
  41
  42 int
  43 ref_compare(const struct ref *ref1, const struct ref *ref2)
  44 {
  45         if (ref1->type != ref2->type)
  46                 return ref1->type - ref2->type;
  47         return strcmp_numeric(ref1->name, ref2->name);
  48 }
  49
  50 void
  51 foreach_ref(bool (*visitor)(void *data, const struct ref *ref), void *data)
  52 {
  53         size_t i;
  54
  55         for (i = 0; i < refs_size; i++)
  56                 if (refs[i]->id[0] && !visitor(data, refs[i]))
  57                         break;
  58 }
  59
  60 struct ref *
  61 get_ref_head()
  62 {
  63         return refs_head;
  64 }
  65
  66 struct ref_list *
  67 get_ref_list(const char *id)
  68 {
  69         struct ref_list *list;
  70         size_t i;
  71
  72         for (i = 0; i < ref_lists_size; i++)
  73                 if (!strcmp(id, ref_lists[i]->id))
  74                         return ref_lists[i];
  75
  76         if (!realloc_ref_lists(&ref_lists, ref_lists_size, 1))
  77                 return NULL;
  78         list = calloc(1, sizeof(*list));
  79         if (!list)
  80                 return NULL;
  81         string_copy_rev(list->id, id);
  82
  83         for (i = 0; i < refs_size; i++) {
  84                 if (!strcmp(id, refs[i]->id) &&
  85                     realloc_refs_list(&list->refs, list->size, 1))
  86                         list->refs[list->size++] = refs[i];
  87         }
  88
  89         if (!list->refs) {
  90                 free(list);
  91                 return NULL;
  92         }
  93
  94         qsort(list->refs, list->size, sizeof(*list->refs), compare_refs);
  95         ref_lists[ref_lists_size++] = list;
  96         return list;
  97 }
  98
  99 struct ref_opt {
 100         const char *remote;
 101         const char *head;
 102         enum watch_trigger changed;
 103 };
 104
 105 static void
 106 done_ref_lists(void)
 107 {
 108         int i;
 109
 110         for (i = 0; i < ref_lists_size; i++) {
 111                 struct ref_list *list = ref_lists[i];
 112
 113                 free(list->refs);
 114                 free(list);
 115         }
 116
 117         free(ref_lists);
 118         ref_lists = NULL;
 119         ref_lists_size = 0;
 120 }
 121
 122 static int
 123 add_to_refs(const char *id, size_t idlen, char *name, size_t namelen, struct ref_opt *opt)
 124 {
 125         struct ref *ref = NULL;
 126         enum reference_type type = REFERENCE_BRANCH;
 127         int pos;
 128
 129         if (!prefixcmp(name, "refs/tags/")) {
 130                 type = REFERENCE_TAG;
 131                 if (!suffixcmp(name, namelen, "^{}")) {
 132                         namelen -= 3;
 133                         name[namelen] = 0;
 134                 } else {
 135                         type = REFERENCE_LOCAL_TAG;
 136                 }
 137
 138                 namelen -= STRING_SIZE("refs/tags/");
 139                 name    += STRING_SIZE("refs/tags/");
 140
 141         } else if (!prefixcmp(name, "refs/remotes/")) {
 142                 type = REFERENCE_REMOTE;
 143                 namelen -= STRING_SIZE("refs/remotes/");
 144                 name    += STRING_SIZE("refs/remotes/");
 145                 if (!strcmp(opt->remote, name))
 146                         type = REFERENCE_TRACKED_REMOTE;
 147
 148         } else if (!prefixcmp(name, "refs/replace/")) {
 149                 type = REFERENCE_REPLACE;
 150                 id      = name + strlen("refs/replace/");
 151                 idlen   = namelen - strlen("refs/replace/");
 152                 name    = "replaced";
 153                 namelen = strlen(name);
 154
 155         } else if (!prefixcmp(name, "refs/heads/")) {
 156                 namelen -= STRING_SIZE("refs/heads/");
 157                 name    += STRING_SIZE("refs/heads/");
 158                 if (strlen(opt->head) == namelen &&
 159                     !strncmp(opt->head, name, namelen))
 160                         type = REFERENCE_HEAD;
 161
 162         } else if (!strcmp(name, "HEAD")) {
 163                 /* Handle the case of HEAD not being a symbolic ref,
 164                  * i.e. during a rebase. */
 165                 if (*opt->head)
 166                         return OK;
 167                 type = REFERENCE_HEAD;
 168         }
 169
 170         /* If we are reloading or it's an annotated tag, replace the
 171          * previous SHA1 with the resolved commit id; relies on the fact
 172          * git-ls-remote lists the commit id of an annotated tag right
 173          * before the commit id it points to. */
 174         for (pos = 0; pos < refs_size; pos++) {
 175                 int cmp = type == REFERENCE_REPLACE
 176                         ? strcmp(id, refs[pos]->id) : strcmp(name, refs[pos]->name);
 177
 178                 if (!cmp) {
 179                         ref = refs[pos];
 180                         break;
 181                 }
 182         }
 183
 184         if (!ref) {
 185                 if (!realloc_refs(&refs, refs_size, 1))
 186                         return ERR;
 187                 ref = calloc(1, sizeof(*ref) + namelen);
 188                 if (!ref)
 189                         return ERR;
 190                 refs[refs_size++] = ref;
 191                 strncpy(ref->name, name, namelen);
 192         }
 193
 194         if (strncmp(ref->id, id, idlen))
 195                 opt->changed |= WATCH_REFS;
 196
 197         ref->valid = TRUE;
 198         ref->type = type;
 199         string_ncopy_do(ref->id, SIZEOF_REV, id, idlen);
 200
 201         if (type == REFERENCE_HEAD) {
 202                 if (!refs_head ||
 203                     (refs_head != ref && memcmp(refs_head, ref, sizeof(*ref))))
 204                         opt->changed |= WATCH_HEAD;
 205                 refs_head = ref;
 206         }
 207         return OK;
 208 }
 209
 210 static int
 211 read_ref(char *id, size_t idlen, char *name, size_t namelen, void *data)
 212 {
 213         return add_to_refs(id, idlen, name, namelen, data);
 214 }
 215
 216 static int
 217 reload_refs(bool force)
 218 {
 219         const char *ls_remote_argv[SIZEOF_ARG] = {
 220                 "git", "ls-remote", repo.git_dir, NULL
 221         };
 222         static bool init = FALSE;
 223         struct ref_opt opt = { repo.remote, repo.head, WATCH_NONE };
 224         struct repo_info old_repo = repo;
 225         size_t i;
 226
 227         if (!init) {
 228                 if (!argv_from_env(ls_remote_argv, "TIG_LS_REMOTE"))
 229                         return ERR;
 230                 init = TRUE;
 231         }
 232
 233         if (!*repo.git_dir)
 234                 return OK;
 235
 236         if (force || !*repo.head)
 237                 load_repo_head();
 238
 239         if (strcmp(old_repo.head, repo.head))
 240                 opt.changed |= WATCH_HEAD;
 241
 242         refs_head = NULL;
 243         for (i = 0; i < refs_size; i++)
 244                 refs[i]->valid = 0;
 245
 246         done_ref_lists();
 247
 248         if (io_run_load(ls_remote_argv, "\t", read_ref, &opt) == ERR)
 249                 return ERR;
 250
 251         for (i = 0; i < refs_size; i++)
 252                 if (!refs[i]->valid) {
 253                         refs[i]->id[0] = 0;
 254                         opt.changed |= WATCH_REFS;
 255                 }
 256
 257
 258         if (opt.changed)
 259                 watch_apply(NULL, opt.changed);
 260         qsort(refs, refs_size, sizeof(*refs), compare_refs);
 261
 262         return OK;
 263 }
 264
 265 int
 266 load_refs(bool force)
 267 {
 268         static bool loaded = FALSE;
 269
 270         if (!force && loaded)
 271                 return OK;
 272
 273         loaded = TRUE;
 274         return reload_refs(force);
 275 }
 276
 277 int
 278 add_ref(const char *id, char *name, const char *remote_name, const char *head)
 279 {
 280         struct ref_opt opt = { remote_name, head };
 281
 282         return add_to_refs(id, strlen(id), name, strlen(name), &opt);
 283 }
 284
 285 void
 286 ref_update_env(struct argv_env *env, const struct ref *ref, bool clear)
 287 {
 288         if (clear)
 289                 env->tag[0] = env->remote[0] = env->branch[0] = 0;
 290
 291         string_copy_rev(env->commit, ref->id);
 292
 293         if (ref_is_tag(ref)) {
 294                 string_ncopy(env->tag, ref->name, strlen(ref->name));
 295
 296         } else if (ref_is_remote(ref)) {
 297                 const char *sep = strchr(ref->name, '/');
 298
 299                 if (!sep)
 300                         return;
 301                 string_ncopy(env->remote, ref->name, sep - ref->name);
 302                 string_ncopy(env->branch, sep + 1, strlen(sep + 1));
 303
 304         } else if (ref->type == REFERENCE_BRANCH) {
 305                 string_ncopy(env->branch, ref->name, strlen(ref->name));
 306         }
 307 }
 308
 309 static struct ref_format **ref_formats;
 310
 311 const struct ref_format *
 312 get_ref_format(struct ref *ref)
 313 {
 314         static const struct ref_format default_format = { "", "" };
 315
 316         if (ref_formats) {
 317                 struct ref_format *format = ref_formats[ref->type];
 318
 319                 if (!format && ref_is_tag(ref))
 320                         format = ref_formats[REFERENCE_TAG];
 321                 if (!format && ref_is_remote(ref))
 322                         format = ref_formats[REFERENCE_REMOTE];
 323                 if (!format)
 324                         format = ref_formats[REFERENCE_BRANCH];
 325                 if (format)
 326                         return format;
 327         }
 328
 329         return &default_format;
 330 }
 331
 332 static enum status_code
 333 parse_ref_format_arg(const char *arg, const struct enum_map *map)
 334 {
 335         size_t arglen = strlen(arg);
 336         const char *pos;
 337
 338         for (pos = arg; *pos && arglen > 0; pos++, arglen--) {
 339                 enum reference_type type;
 340
 341                 for (type = 0; type < map->size; type++) {
 342                         const struct enum_map_entry *entry = &map->entries[type];
 343                         struct ref_format *format;
 344
 345                         if (arglen < entry->namelen ||
 346                             string_enum_compare(pos, entry->name, entry->namelen))
 347                                 continue;
 348
 349                         format = malloc(sizeof(*format));
 350                         if (!format)
 351                                 return ERROR_OUT_OF_MEMORY;
 352                         format->start = strndup(arg, pos - arg);
 353                         format->end = strdup(pos + entry->namelen);
 354                         if (!format->start || !format->end) {
 355                                 free((void *) format->start);
 356                                 free((void *) format->end);
 357                                 free(format);
 358                                 return ERROR_OUT_OF_MEMORY;
 359                         }
 360
 361                         ref_formats[type] = format;
 362                         return SUCCESS;
 363                 }
 364         }
 365
 366         return error("Unknown ref format: %s", arg);
 367 }
 368
 369 enum status_code
 370 parse_ref_formats(const char *argv[])
 371 {
 372         const struct enum_map *map = reference_type_map;
 373         int argc;
 374
 375         if (!ref_formats) {
 376                 ref_formats = calloc(reference_type_map->size, sizeof(struct ref_format *));
 377                 if (!ref_formats)
 378                         return ERROR_OUT_OF_MEMORY;
 379         }
 380
 381         for (argc = 0; argv[argc]; argc++) {
 382                 enum status_code code = parse_ref_format_arg(argv[argc], map);
 383                 if (code != SUCCESS)
 384                         return code;
 385         }
 386
 387         return SUCCESS;
 388 }
 389
 390 /* vim: set ts=8 sw=8 noexpandtab: */