branch.c

   1 #include "cache.h"
   2 #include "branch.h"
   3 #include "refs.h"
   4 #include "remote.h"
   5 #include "commit.h"
   6
   7 struct tracking {
   8         struct refspec spec;
   9         char *src;
  10         const char *remote;
  11         int matches;
  12 };
  13
  14 static int find_tracked_branch(struct remote *remote, void *priv)
  15 {
  16         struct tracking *tracking = priv;
  17
  18         if (!remote_find_tracking(remote, &tracking->spec)) {
  19                 if (++tracking->matches == 1) {
  20                         tracking->src = tracking->spec.src;
  21                         tracking->remote = remote->name;
  22                 } else {
  23                         free(tracking->spec.src);
  24                         if (tracking->src) {
  25                                 free(tracking->src);
  26                                 tracking->src = NULL;
  27                         }
  28                 }
  29                 tracking->spec.src = NULL;
  30         }
  31
  32         return 0;
  33 }
  34
  35 static int should_setup_rebase(const char *origin)
  36 {
  37         switch (autorebase) {
  38         case AUTOREBASE_NEVER:
  39                 return 0;
  40         case AUTOREBASE_LOCAL:
  41                 return origin == NULL;
  42         case AUTOREBASE_REMOTE:
  43                 return origin != NULL;
  44         case AUTOREBASE_ALWAYS:
  45                 return 1;
  46         }
  47         return 0;
  48 }
  49
  50 void install_branch_config(int flag, const char *local, const char *origin, const char *remote)
  51 {
  52         const char *shortname = remote + 11;
  53         int remote_is_branch = !prefixcmp(remote, "refs/heads/");
  54         struct strbuf key = STRBUF_INIT;
  55         int rebasing = should_setup_rebase(origin);
  56
  57         if (remote_is_branch
  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 (remote_is_branch && origin)
  81                         printf_ln(rebasing ?
  82                                   _("Branch %s set up to track remote branch %s from %s by rebasing.") :
  83                                   _("Branch %s set up to track remote branch %s from %s."),
  84                                   local, shortname, origin);
  85                 else if (remote_is_branch && !origin)
  86                         printf_ln(rebasing ?
  87                                   _("Branch %s set up to track local branch %s by rebasing.") :
  88                                   _("Branch %s set up to track local branch %s."),
  89                                   local, shortname);
  90                 else if (!remote_is_branch && origin)
  91                         printf_ln(rebasing ?
  92                                   _("Branch %s set up to track remote ref %s by rebasing.") :
  93                                   _("Branch %s set up to track remote ref %s."),
  94                                   local, remote);
  95                 else if (!remote_is_branch && !origin)
  96                         printf_ln(rebasing ?
  97                                   _("Branch %s set up to track local ref %s by rebasing.") :
  98                                   _("Branch %s set up to track local ref %s."),
  99                                   local, remote);
 100                 else
 101                         die("BUG: impossible combination of %d and %p",
 102                             remote_is_branch, origin);
 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         if (strlen(new_ref) > 1024 - 7 - 7 - 1)
 118                 return error(_("Tracking not set up: name too long: %s"),
 119                                 new_ref);
 120
 121         memset(&tracking, 0, sizeof(tracking));
 122         tracking.spec.dst = (char *)orig_ref;
 123         if (for_each_remote(find_tracked_branch, &tracking))
 124                 return 1;
 125
 126         if (!tracking.matches)
 127                 switch (track) {
 128                 case BRANCH_TRACK_ALWAYS:
 129                 case BRANCH_TRACK_EXPLICIT:
 130                 case BRANCH_TRACK_OVERRIDE:
 131                         break;
 132                 default:
 133                         return 1;
 134                 }
 135
 136         if (tracking.matches > 1)
 137                 return error(_("Not tracking: ambiguous information for ref %s"),
 138                                 orig_ref);
 139
 140         install_branch_config(config_flags, new_ref, tracking.remote,
 141                               tracking.src ? tracking.src : orig_ref);
 142
 143         free(tracking.src);
 144         return 0;
 145 }
 146
 147 struct branch_desc_cb {
 148         const char *config_name;
 149         const char *value;
 150 };
 151
 152 static int read_branch_desc_cb(const char *var, const char *value, void *cb)
 153 {
 154         struct branch_desc_cb *desc = cb;
 155         if (strcmp(desc->config_name, var))
 156                 return 0;
 157         free((char *)desc->value);
 158         return git_config_string(&desc->value, var, value);
 159 }
 160
 161 int read_branch_desc(struct strbuf *buf, const char *branch_name)
 162 {
 163         struct branch_desc_cb cb;
 164         struct strbuf name = STRBUF_INIT;
 165         strbuf_addf(&name, "branch.%s.description", branch_name);
 166         cb.config_name = name.buf;
 167         cb.value = NULL;
 168         if (git_config(read_branch_desc_cb, &cb) < 0) {
 169                 strbuf_release(&name);
 170                 return -1;
 171         }
 172         if (cb.value)
 173                 strbuf_addstr(buf, cb.value);
 174         strbuf_release(&name);
 175         return 0;
 176 }
 177
 178 int validate_new_branchname(const char *name, struct strbuf *ref,
 179                             int force, int attr_only)
 180 {
 181         if (strbuf_check_branch_ref(ref, name))
 182                 die(_("'%s' is not a valid branch name."), name);
 183
 184         if (!ref_exists(ref->buf))
 185                 return 0;
 186         else if (!force && !attr_only)
 187                 die(_("A branch named '%s' already exists."), ref->buf + strlen("refs/heads/"));
 188
 189         if (!attr_only) {
 190                 const char *head;
 191                 unsigned char sha1[20];
 192
 193                 head = resolve_ref_unsafe("HEAD", sha1, 0, NULL);
 194                 if (!is_bare_repository() && head && !strcmp(head, ref->buf))
 195                         die(_("Cannot force update the current branch."));
 196         }
 197         return 1;
 198 }
 199
 200 static int check_tracking_branch(struct remote *remote, void *cb_data)
 201 {
 202         char *tracking_branch = cb_data;
 203         struct refspec query;
 204         memset(&query, 0, sizeof(struct refspec));
 205         query.dst = tracking_branch;
 206         return !remote_find_tracking(remote, &query);
 207 }
 208
 209 static int validate_remote_tracking_branch(char *ref)
 210 {
 211         return !for_each_remote(check_tracking_branch, ref);
 212 }
 213
 214 static const char upstream_not_branch[] =
 215 N_("Cannot setup tracking information; starting point '%s' is not a branch.");
 216 static const char upstream_missing[] =
 217 N_("the requested upstream branch '%s' does not exist");
 218 static const char upstream_advice[] =
 219 N_("\n"
 220 "If you are planning on basing your work on an upstream\n"
 221 "branch that already exists at the remote, you may need to\n"
 222 "run \"git fetch\" to retrieve it.\n"
 223 "\n"
 224 "If you are planning to push out a new local branch that\n"
 225 "will track its remote counterpart, you may want to use\n"
 226 "\"git push -u\" to set the upstream config as you push.");
 227
 228 void create_branch(const char *head,
 229                    const char *name, const char *start_name,
 230                    int force, int reflog, int clobber_head,
 231                    int quiet, enum branch_track track)
 232 {
 233         struct ref_lock *lock = NULL;
 234         struct commit *commit;
 235         unsigned char sha1[20];
 236         char *real_ref, msg[PATH_MAX + 20];
 237         struct strbuf ref = STRBUF_INIT;
 238         int forcing = 0;
 239         int dont_change_ref = 0;
 240         int explicit_tracking = 0;
 241
 242         if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
 243                 explicit_tracking = 1;
 244
 245         if (validate_new_branchname(name, &ref, force,
 246                                     track == BRANCH_TRACK_OVERRIDE ||
 247                                     clobber_head)) {
 248                 if (!force)
 249                         dont_change_ref = 1;
 250                 else
 251                         forcing = 1;
 252         }
 253
 254         real_ref = NULL;
 255         if (get_sha1(start_name, sha1)) {
 256                 if (explicit_tracking) {
 257                         if (advice_set_upstream_failure) {
 258                                 error(_(upstream_missing), start_name);
 259                                 advise(_(upstream_advice));
 260                                 exit(1);
 261                         }
 262                         die(_(upstream_missing), start_name);
 263                 }
 264                 die(_("Not a valid object name: '%s'."), start_name);
 265         }
 266
 267         switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {
 268         case 0:
 269                 /* Not branching from any existing branch */
 270                 if (explicit_tracking)
 271                         die(_(upstream_not_branch), start_name);
 272                 break;
 273         case 1:
 274                 /* Unique completion -- good, only if it is a real branch */
 275                 if (prefixcmp(real_ref, "refs/heads/") &&
 276                     validate_remote_tracking_branch(real_ref)) {
 277                         if (explicit_tracking)
 278                                 die(_(upstream_not_branch), start_name);
 279                         else
 280                                 real_ref = NULL;
 281                 }
 282                 break;
 283         default:
 284                 die(_("Ambiguous object name: '%s'."), start_name);
 285                 break;
 286         }
 287
 288         if ((commit = lookup_commit_reference(sha1)) == NULL)
 289                 die(_("Not a valid branch point: '%s'."), start_name);
 290         hashcpy(sha1, commit->object.sha1);
 291
 292         if (!dont_change_ref) {
 293                 lock = lock_any_ref_for_update(ref.buf, NULL, 0);
 294                 if (!lock)
 295                         die_errno(_("Failed to lock ref for update"));
 296         }
 297
 298         if (reflog)
 299                 log_all_ref_updates = 1;
 300
 301         if (forcing)
 302                 snprintf(msg, sizeof msg, "branch: Reset to %s",
 303                          start_name);
 304         else if (!dont_change_ref)
 305                 snprintf(msg, sizeof msg, "branch: Created from %s",
 306                          start_name);
 307
 308         if (real_ref && track)
 309                 setup_tracking(ref.buf+11, real_ref, track, quiet);
 310
 311         if (!dont_change_ref)
 312                 if (write_ref_sha1(lock, sha1, msg) < 0)
 313                         die_errno(_("Failed to write ref"));
 314
 315         strbuf_release(&ref);
 316         free(real_ref);
 317 }
 318
 319 void remove_branch_state(void)
 320 {
 321         unlink(git_path("CHERRY_PICK_HEAD"));
 322         unlink(git_path("REVERT_HEAD"));
 323         unlink(git_path("MERGE_HEAD"));
 324         unlink(git_path("MERGE_RR"));
 325         unlink(git_path("MERGE_MSG"));
 326         unlink(git_path("MERGE_MODE"));
 327         unlink(git_path("SQUASH_MSG"));
 328 }