branch.c

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