refs.c

   1 /* Copyright (c) 2006-2013 Jonas Fonseca <fonseca@diku.dk>
   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.h"
  15 #include "io.h"
  16 #include "refs.h"
  17
  18 static struct ref **refs = NULL;
  19 static size_t refs_size = 0;
  20 static struct ref *refs_head = NULL;
  21
  22 static struct ref_list **ref_lists = NULL;
  23 static size_t ref_lists_size = 0;
  24
  25 DEFINE_ALLOCATOR(realloc_refs, struct ref *, 256)
  26 DEFINE_ALLOCATOR(realloc_refs_list, struct ref *, 8)
  27 DEFINE_ALLOCATOR(realloc_ref_lists, struct ref_list *, 8)
  28
  29 static int
  30 compare_refs(const void *ref1_, const void *ref2_)
  31 {
  32         const struct ref *ref1 = *(const struct ref **)ref1_;
  33         const struct ref *ref2 = *(const struct ref **)ref2_;
  34
  35         if (ref1->tag != ref2->tag)
  36                 return ref2->tag - ref1->tag;
  37         if (ref1->ltag != ref2->ltag)
  38                 return ref2->ltag - ref1->ltag;
  39         if (ref1->head != ref2->head)
  40                 return ref2->head - ref1->head;
  41         if (ref1->tracked != ref2->tracked)
  42                 return ref2->tracked - ref1->tracked;
  43         if (ref1->replace != ref2->replace)
  44                 return ref2->replace - ref1->replace;
  45         /* Order remotes last. */
  46         if (ref1->remote != ref2->remote)
  47                 return ref1->remote - ref2->remote;
  48         return strcmp(ref1->name, ref2->name);
  49 }
  50
  51 void
  52 foreach_ref(bool (*visitor)(void *data, const struct ref *ref), void *data)
  53 {
  54         size_t i;
  55
  56         for (i = 0; i < refs_size; i++)
  57                 if (refs[i]->id[0] && !visitor(data, refs[i]))
  58                         break;
  59 }
  60
  61 struct ref *
  62 get_ref_head()
  63 {
  64         return refs_head;
  65 }
  66
  67 struct ref_list *
  68 get_ref_list(const char *id)
  69 {
  70         struct ref_list *list;
  71         size_t i;
  72
  73         for (i = 0; i < ref_lists_size; i++)
  74                 if (!strcmp(id, ref_lists[i]->id))
  75                         return ref_lists[i];
  76
  77         if (!realloc_ref_lists(&ref_lists, ref_lists_size, 1))
  78                 return NULL;
  79         list = calloc(1, sizeof(*list));
  80         if (!list)
  81                 return NULL;
  82         string_copy_rev(list->id, id);
  83
  84         for (i = 0; i < refs_size; i++) {
  85                 if (!strcmp(id, refs[i]->id) &&
  86                     realloc_refs_list(&list->refs, list->size, 1))
  87                         list->refs[list->size++] = refs[i];
  88         }
  89
  90         if (!list->refs) {
  91                 free(list);
  92                 return NULL;
  93         }
  94
  95         qsort(list->refs, list->size, sizeof(*list->refs), compare_refs);
  96         ref_lists[ref_lists_size++] = list;
  97         return list;
  98 }
  99
 100 struct ref_opt {
 101         const char *remote;
 102         const char *head;
 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         bool tag = FALSE;
 127         bool ltag = FALSE;
 128         bool remote = FALSE;
 129         bool replace = FALSE;
 130         bool tracked = FALSE;
 131         bool head = FALSE;
 132         int pos;
 133
 134         if (!prefixcmp(name, "refs/tags/")) {
 135                 if (!suffixcmp(name, namelen, "^{}")) {
 136                         namelen -= 3;
 137                         name[namelen] = 0;
 138                 } else {
 139                         ltag = TRUE;
 140                 }
 141
 142                 tag = TRUE;
 143                 namelen -= STRING_SIZE("refs/tags/");
 144                 name    += STRING_SIZE("refs/tags/");
 145
 146         } else if (!prefixcmp(name, "refs/remotes/")) {
 147                 remote = TRUE;
 148                 namelen -= STRING_SIZE("refs/remotes/");
 149                 name    += STRING_SIZE("refs/remotes/");
 150                 tracked  = !strcmp(opt->remote, name);
 151
 152         } else if (!prefixcmp(name, "refs/replace/")) {
 153                 replace = TRUE;
 154                 id      = name + strlen("refs/replace/");
 155                 idlen   = namelen - strlen("refs/replace/");
 156                 name    = "replaced";
 157                 namelen = strlen(name);
 158
 159         } else if (!prefixcmp(name, "refs/heads/")) {
 160                 namelen -= STRING_SIZE("refs/heads/");
 161                 name    += STRING_SIZE("refs/heads/");
 162                 head     = strlen(opt->head) == namelen
 163                            && !strncmp(opt->head, name, namelen);
 164
 165         } else if (!strcmp(name, "HEAD")) {
 166                 /* Handle the case of HEAD not being a symbolic ref,
 167                  * i.e. during a rebase. */
 168                 if (*opt->head)
 169                         return OK;
 170                 head = TRUE;
 171         }
 172
 173         /* If we are reloading or it's an annotated tag, replace the
 174          * previous SHA1 with the resolved commit id; relies on the fact
 175          * git-ls-remote lists the commit id of an annotated tag right
 176          * before the commit id it points to. */
 177         for (pos = 0; pos < refs_size; pos++) {
 178                 int cmp = replace ? strcmp(id, refs[pos]->id) : strcmp(name, refs[pos]->name);
 179
 180                 if (!cmp) {
 181                         ref = refs[pos];
 182                         break;
 183                 }
 184         }
 185
 186         if (!ref) {
 187                 if (!realloc_refs(&refs, refs_size, 1))
 188                         return ERR;
 189                 ref = calloc(1, sizeof(*ref) + namelen);
 190                 if (!ref)
 191                         return ERR;
 192                 refs[refs_size++] = ref;
 193                 strncpy(ref->name, name, namelen);
 194         }
 195
 196         ref->valid = TRUE;
 197         ref->head = head;
 198         ref->tag = tag;
 199         ref->ltag = ltag;
 200         ref->remote = remote;
 201         ref->replace = replace;
 202         ref->tracked = tracked;
 203         string_ncopy_do(ref->id, SIZEOF_REV, id, idlen);
 204
 205         if (head)
 206                 refs_head = ref;
 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 int
 217 reload_refs(const char *git_dir, const char *remote_name, char *head, size_t headlen)
 218 {
 219         const char *head_argv[] = {
 220                 "git", "symbolic-ref", "HEAD", NULL
 221         };
 222         const char *ls_remote_argv[SIZEOF_ARG] = {
 223                 "git", "ls-remote", git_dir, NULL
 224         };
 225         static bool init = FALSE;
 226         struct ref_opt opt = { remote_name, head };
 227         size_t i;
 228
 229         if (!init) {
 230                 if (!argv_from_env(ls_remote_argv, "TIG_LS_REMOTE"))
 231                         return ERR;
 232                 init = TRUE;
 233         }
 234
 235         if (!*git_dir)
 236                 return OK;
 237
 238         if (!*head && io_run_buf(head_argv, head, headlen) &&
 239             !prefixcmp(head, "refs/heads/")) {
 240                 char *offset = head + STRING_SIZE("refs/heads/");
 241
 242                 memmove(head, offset, strlen(offset) + 1);
 243         }
 244
 245         refs_head = NULL;
 246         for (i = 0; i < refs_size; i++)
 247                 refs[i]->valid = 0;
 248
 249         done_ref_lists();
 250
 251         if (io_run_load(ls_remote_argv, "\t", read_ref, &opt) == ERR)
 252                 return ERR;
 253
 254         for (i = 0; i < refs_size; i++)
 255                 if (!refs[i]->valid)
 256                         refs[i]->id[0] = 0;
 257
 258         qsort(refs, refs_size, sizeof(*refs), compare_refs);
 259
 260         return OK;
 261 }
 262
 263 int
 264 add_ref(const char *id, char *name, const char *remote_name, const char *head)
 265 {
 266         struct ref_opt opt = { remote_name, head };
 267
 268         return add_to_refs(id, strlen(id), name, strlen(name), &opt);
 269 }
 270
 271 /* vim: set ts=8 sw=8 noexpandtab: */