branch.c

   1 #include "git-compat-util.h"
   2 #include "cache.h"
   3 #include "branch.h"
   4 #include "refs.h"
   5 #include "remote.h"
   6 #include "commit.h"
   7
   8 struct tracking {
   9         struct refspec spec;
  10         char *src;
  11         const char *remote;
  12         int matches;
  13 };
  14
  15 static int find_tracked_branch(struct remote *remote, void *priv)
  16 {
  17         struct tracking *tracking = priv;
  18
  19         if (!remote_find_tracking(remote, &tracking->spec)) {
  20                 if (++tracking->matches == 1) {
  21                         tracking->src = tracking->spec.src;
  22                         tracking->remote = remote->name;
  23                 } else {
  24                         free(tracking->spec.src);
  25                         if (tracking->src) {
  26                                 free(tracking->src);
  27                                 tracking->src = NULL;
  28                         }
  29                 }
  30                 tracking->spec.src = NULL;
  31         }
  32
  33         return 0;
  34 }
  35
  36 static int should_setup_rebase(const char *origin)
  37 {
  38         switch (autorebase) {
  39         case AUTOREBASE_NEVER:
  40                 return 0;
  41         case AUTOREBASE_LOCAL:
  42                 return origin == NULL;
  43         case AUTOREBASE_REMOTE:
  44                 return origin != NULL;
  45         case AUTOREBASE_ALWAYS:
  46                 return 1;
  47         }
  48         return 0;
  49 }
  50
  51 void install_branch_config(int flag, const char *local, const char *origin, const char *remote)
  52 {
  53         const char *shortname = NULL;
  54         struct strbuf key = STRBUF_INIT;
  55         int rebasing = should_setup_rebase(origin);
  56
  57         if (skip_prefix(remote, "refs/heads/", &shortname)
  58             && !strcmp(local, shortname)
  59             && !origin) {
  60                 warning(_("Not setting branch %s as its own upstream."),
  61                         local);
  62                 return;
  63         }
  64
  65         strbuf_addf(&key, "branch.%s.remote", local);
  66         git_config_set(key.buf, origin ? origin : ".");
  67
  68         strbuf_reset(&key);
  69         strbuf_addf(&key, "branch.%s.merge", local);
  70         git_config_set(key.buf, remote);
  71
  72         if (rebasing) {
  73                 strbuf_reset(&key);
  74                 strbuf_addf(&key, "branch.%s.rebase", local);
  75                 git_config_set(key.buf, "true");
  76         }
  77         strbuf_release(&key);
  78
  79         if (flag & BRANCH_CONFIG_VERBOSE) {
  80                 if (shortname) {
  81                         if (origin)
  82                                 printf_ln(rebasing ?
  83                                           _("Branch %s set up to track remote branch %s from %s by rebasing.") :
  84                                           _("Branch %s set up to track remote branch %s from %s."),
  85                                           local, shortname, origin);
  86                         else
  87                                 printf_ln(rebasing ?
  88                                           _("Branch %s set up to track local branch %s by rebasing.") :
  89                                           _("Branch %s set up to track local branch %s."),
  90                                           local, shortname);
  91                 } else {
  92                         if (origin)
  93                                 printf_ln(rebasing ?
  94                                           _("Branch %s set up to track remote ref %s by rebasing.") :
  95                                           _("Branch %s set up to track remote ref %s."),
  96                                           local, remote);
  97                         else
  98                                 printf_ln(rebasing ?
  99                                           _("Branch %s set up to track local ref %s by rebasing.") :
 100                                           _("Branch %s set up to track local ref %s."),
 101                                           local, remote);
 102                 }
 103         }
 104 }
 105
 106 /*
 107  * This is called when new_ref is branched off of orig_ref, and tries
 108  * to infer the settings for branch.<new_ref>.{remote,merge} from the
 109  * config.
 110  */
 111 static int setup_tracking(const char *new_ref, const char *orig_ref,
 112                           enum branch_track track, int quiet)
 113 {
 114         struct tracking tracking;
 115         int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;
 116
 117         memset(&tracking, 0, sizeof(tracking));
 118         tracking.spec.dst = (char *)orig_ref;
 119         if (for_each_remote(find_tracked_branch, &tracking))
 120                 return 1;
 121
 122         if (!tracking.matches)
 123                 switch (track) {
 124                 case BRANCH_TRACK_ALWAYS:
 125                 case BRANCH_TRACK_EXPLICIT:
 126                 case BRANCH_TRACK_OVERRIDE:
 127                         break;
 128                 default:
 129                         return 1;
 130                 }
 131
 132         if (tracking.matches > 1)
 133                 return error(_("Not tracking: ambiguous information for ref %s"),
 134                                 orig_ref);
 135
 136         install_branch_config(config_flags, new_ref, tracking.remote,
 137                               tracking.src ? tracking.src : orig_ref);
 138
 139         free(tracking.src);
 140         return 0;
 141 }
 142
 143 int read_branch_desc(struct strbuf *buf, const char *branch_name)
 144 {
 145         char *v = NULL;
 146         struct strbuf name = STRBUF_INIT;
 147         strbuf_addf(&name, "branch.%s.description", branch_name);
 148         if (git_config_get_string(name.buf, &v)) {
 149                 strbuf_release(&name);
 150                 return -1;
 151         }
 152         strbuf_addstr(buf, v);
 153         free(v);
 154         strbuf_release(&name);
 155         return 0;
 156 }
 157
 158 int validate_new_branchname(const char *name, struct strbuf *ref,
 159                             int force, int attr_only)
 160 {
 161         if (strbuf_check_branch_ref(ref, name))
 162                 die(_("'%s' is not a valid branch name."), name);
 163
 164         if (!ref_exists(ref->buf))
 165                 return 0;
 166         else if (!force && !attr_only)
 167                 die(_("A branch named '%s' already exists."), ref->buf + strlen("refs/heads/"));
 168
 169         if (!attr_only) {
 170                 const char *head;
 171                 unsigned char sha1[20];
 172
 173                 head = resolve_ref_unsafe("HEAD", 0, sha1, NULL);
 174                 if (!is_bare_repository() && head && !strcmp(head, ref->buf))
 175                         die(_("Cannot force update the current branch."));
 176         }
 177         return 1;
 178 }
 179
 180 static int check_tracking_branch(struct remote *remote, void *cb_data)
 181 {
 182         char *tracking_branch = cb_data;
 183         struct refspec query;
 184         memset(&query, 0, sizeof(struct refspec));
 185         query.dst = tracking_branch;
 186         return !remote_find_tracking(remote, &query);
 187 }
 188
 189 static int validate_remote_tracking_branch(char *ref)
 190 {
 191         return !for_each_remote(check_tracking_branch, ref);
 192 }
 193
 194 static const char upstream_not_branch[] =
 195 N_("Cannot setup tracking information; starting point '%s' is not a branch.");
 196 static const char upstream_missing[] =
 197 N_("the requested upstream branch '%s' does not exist");
 198 static const char upstream_advice[] =
 199 N_("\n"
 200 "If you are planning on basing your work on an upstream\n"
 201 "branch that already exists at the remote, you may need to\n"
 202 "run \"git fetch\" to retrieve it.\n"
 203 "\n"
 204 "If you are planning to push out a new local branch that\n"
 205 "will track its remote counterpart, you may want to use\n"
 206 "\"git push -u\" to set the upstream config as you push.");
 207
 208 void create_branch(const char *head,
 209                    const char *name, const char *start_name,
 210                    int force, int reflog, int clobber_head,
 211                    int quiet, enum branch_track track)
 212 {
 213         struct commit *commit;
 214         unsigned char sha1[20];
 215         char *real_ref, msg[PATH_MAX + 20];
 216         struct strbuf ref = STRBUF_INIT;
 217         int forcing = 0;
 218         int dont_change_ref = 0;
 219         int explicit_tracking = 0;
 220
 221         if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
 222                 explicit_tracking = 1;
 223
 224         if (validate_new_branchname(name, &ref, force,
 225                                     track == BRANCH_TRACK_OVERRIDE ||
 226                                     clobber_head)) {
 227                 if (!force)
 228                         dont_change_ref = 1;
 229                 else
 230                         forcing = 1;
 231         }
 232
 233         real_ref = NULL;
 234         if (get_sha1(start_name, sha1)) {
 235                 if (explicit_tracking) {
 236                         if (advice_set_upstream_failure) {
 237                                 error(_(upstream_missing), start_name);
 238                                 advise(_(upstream_advice));
 239                                 exit(1);
 240                         }
 241                         die(_(upstream_missing), start_name);
 242                 }
 243                 die(_("Not a valid object name: '%s'."), start_name);
 244         }
 245
 246         switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {
 247         case 0:
 248                 /* Not branching from any existing branch */
 249                 if (explicit_tracking)
 250                         die(_(upstream_not_branch), start_name);
 251                 break;
 252         case 1:
 253                 /* Unique completion -- good, only if it is a real branch */
 254                 if (!starts_with(real_ref, "refs/heads/") &&
 255                     validate_remote_tracking_branch(real_ref)) {
 256                         if (explicit_tracking)
 257                                 die(_(upstream_not_branch), start_name);
 258                         else
 259                                 real_ref = NULL;
 260                 }
 261                 break;
 262         default:
 263                 die(_("Ambiguous object name: '%s'."), start_name);
 264                 break;
 265         }
 266
 267         if ((commit = lookup_commit_reference(sha1)) == NULL)
 268                 die(_("Not a valid branch point: '%s'."), start_name);
 269         hashcpy(sha1, commit->object.sha1);
 270
 271         if (forcing)
 272                 snprintf(msg, sizeof msg, "branch: Reset to %s",
 273                          start_name);
 274         else if (!dont_change_ref)
 275                 snprintf(msg, sizeof msg, "branch: Created from %s",
 276                          start_name);
 277
 278         if (reflog)
 279                 log_all_ref_updates = 1;
 280
 281         if (!dont_change_ref) {
 282                 struct ref_transaction *transaction;
 283                 struct strbuf err = STRBUF_INIT;
 284
 285                 transaction = ref_transaction_begin(&err);
 286                 if (!transaction ||
 287                     ref_transaction_update(transaction, ref.buf,
 288                                            sha1, forcing ? NULL : null_sha1,
 289                                            0, msg, &err) ||
 290                     ref_transaction_commit(transaction, &err))
 291                         die("%s", err.buf);
 292                 ref_transaction_free(transaction);
 293                 strbuf_release(&err);
 294         }
 295
 296         if (real_ref && track)
 297                 setup_tracking(ref.buf + 11, real_ref, track, quiet);
 298
 299         strbuf_release(&ref);
 300         free(real_ref);
 301 }
 302
 303 void remove_branch_state(void)
 304 {
 305         unlink(git_path_cherry_pick_head());
 306         unlink(git_path_revert_head());
 307         unlink(git_path_merge_head());
 308         unlink(git_path_merge_rr());
 309         unlink(git_path_merge_msg());
 310         unlink(git_path_merge_mode());
 311         unlink(git_path_squash_msg());
 312 }
 313
 314 static char *find_linked_symref(const char *symref, const char *branch,
 315                                 const char *id)
 316 {
 317         struct strbuf sb = STRBUF_INIT;
 318         struct strbuf path = STRBUF_INIT;
 319         struct strbuf gitdir = STRBUF_INIT;
 320         char *existing = NULL;
 321
 322         /*
 323          * $GIT_COMMON_DIR/$symref (e.g. HEAD) is practically outside
 324          * $GIT_DIR so resolve_ref_unsafe() won't work (it uses
 325          * git_path). Parse the ref ourselves.
 326          */
 327         if (id)
 328                 strbuf_addf(&path, "%s/worktrees/%s/%s", get_git_common_dir(), id, symref);
 329         else
 330                 strbuf_addf(&path, "%s/%s", get_git_common_dir(), symref);
 331
 332         if (!strbuf_readlink(&sb, path.buf, 0)) {
 333                 if (!starts_with(sb.buf, "refs/") ||
 334                     check_refname_format(sb.buf, 0))
 335                         goto done;
 336         } else if (strbuf_read_file(&sb, path.buf, 0) >= 0 &&
 337             starts_with(sb.buf, "ref:")) {
 338                 strbuf_remove(&sb, 0, strlen("ref:"));
 339                 strbuf_trim(&sb);
 340         } else
 341                 goto done;
 342         if (strcmp(sb.buf, branch))
 343                 goto done;
 344         if (id) {
 345                 strbuf_reset(&path);
 346                 strbuf_addf(&path, "%s/worktrees/%s/gitdir", get_git_common_dir(), id);
 347                 if (strbuf_read_file(&gitdir, path.buf, 0) <= 0)
 348                         goto done;
 349                 strbuf_rtrim(&gitdir);
 350         } else
 351                 strbuf_addstr(&gitdir, get_git_common_dir());
 352         strbuf_strip_suffix(&gitdir, ".git");
 353
 354         existing = strbuf_detach(&gitdir, NULL);
 355 done:
 356         strbuf_release(&path);
 357         strbuf_release(&sb);
 358         strbuf_release(&gitdir);
 359
 360         return existing;
 361 }
 362
 363 char *find_shared_symref(const char *symref, const char *target)
 364 {
 365         struct strbuf path = STRBUF_INIT;
 366         DIR *dir;
 367         struct dirent *d;
 368         char *existing;
 369
 370         if ((existing = find_linked_symref(symref, target, NULL)))
 371                 return existing;
 372
 373         strbuf_addf(&path, "%s/worktrees", get_git_common_dir());
 374         dir = opendir(path.buf);
 375         strbuf_release(&path);
 376         if (!dir)
 377                 return NULL;
 378
 379         while ((d = readdir(dir)) != NULL) {
 380                 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
 381                         continue;
 382                 existing = find_linked_symref(symref, target, d->d_name);
 383                 if (existing)
 384                         goto done;
 385         }
 386 done:
 387         closedir(dir);
 388
 389         return existing;
 390 }
 391
 392 void die_if_checked_out(const char *branch)
 393 {
 394         char *existing;
 395
 396         existing = find_shared_symref("HEAD", branch);
 397         if (existing) {
 398                 skip_prefix(branch, "refs/heads/", &branch);
 399                 die(_("'%s' is already checked out at '%s'"), branch, existing);
 400         }
 401 }