git.oblomov.eu Git - git/blob - 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 = starts_with(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.pullmode", local);
  75                 git_config_set(key.buf, "rebase");
  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 void install_branch_publish(const char *name, const char *remote, const char *remote_ref)
 148 {
 149         struct strbuf key = STRBUF_INIT;
 150
 151         if (!remote && !strcmp(name, remote_ref + 11) &&
 152                         starts_with(remote_ref, "refs/heads")) {
 153                 warning(_("Not setting branch %s as its own publish branch."), name);
 154                 return;
 155         }
 156
 157         strbuf_addf(&key, "branch.%s.pushremote", name);
 158         git_config_set(key.buf, remote ? remote : ".");
 159
 160         strbuf_reset(&key);
 161         strbuf_addf(&key, "branch.%s.push", name);
 162         git_config_set(key.buf, remote_ref);
 163
 164         strbuf_release(&key);
 165 }
 166
 167 int setup_publish(const char *name, const char *ref)
 168 {
 169         struct tracking tracking;
 170         const char *remote, *remote_ref;
 171
 172         memset(&tracking, 0, sizeof(tracking));
 173         tracking.spec.dst = (char *)ref;
 174         if (for_each_remote(find_tracked_branch, &tracking))
 175                 return 1;
 176
 177         if (tracking.matches > 1)
 178                 return error(_("Not tracking: ambiguous information for ref %s"),
 179                                 ref);
 180
 181         remote = tracking.remote;
 182         remote_ref = tracking.src ? tracking.src : ref;
 183
 184         install_branch_publish(name, remote, remote_ref);
 185
 186         free(tracking.src);
 187
 188         return 0;
 189 }
 190
 191 struct branch_desc_cb {
 192         const char *config_name;
 193         const char *value;
 194 };
 195
 196 static int read_branch_desc_cb(const char *var, const char *value, void *cb)
 197 {
 198         struct branch_desc_cb *desc = cb;
 199         if (strcmp(desc->config_name, var))
 200                 return 0;
 201         free((char *)desc->value);
 202         return git_config_string(&desc->value, var, value);
 203 }
 204
 205 int read_branch_desc(struct strbuf *buf, const char *branch_name)
 206 {
 207         struct branch_desc_cb cb;
 208         struct strbuf name = STRBUF_INIT;
 209         strbuf_addf(&name, "branch.%s.description", branch_name);
 210         cb.config_name = name.buf;
 211         cb.value = NULL;
 212         if (git_config(read_branch_desc_cb, &cb) < 0) {
 213                 strbuf_release(&name);
 214                 return -1;
 215         }
 216         if (cb.value)
 217                 strbuf_addstr(buf, cb.value);
 218         strbuf_release(&name);
 219         return 0;
 220 }
 221
 222 int validate_new_branchname(const char *name, struct strbuf *ref,
 223                             int force, int attr_only)
 224 {
 225         if (strbuf_check_branch_ref(ref, name))
 226                 die(_("'%s' is not a valid branch name."), name);
 227
 228         if (!ref_exists(ref->buf))
 229                 return 0;
 230         else if (!force && !attr_only)
 231                 die(_("A branch named '%s' already exists."), ref->buf + strlen("refs/heads/"));
 232
 233         if (!attr_only) {
 234                 const char *head;
 235                 unsigned char sha1[20];
 236
 237                 head = resolve_ref_unsafe("HEAD", sha1, 0, NULL);
 238                 if (!is_bare_repository() && head && !strcmp(head, ref->buf))
 239                         die(_("Cannot force update the current branch."));
 240         }
 241         return 1;
 242 }
 243
 244 static int check_tracking_branch(struct remote *remote, void *cb_data)
 245 {
 246         char *tracking_branch = cb_data;
 247         struct refspec query;
 248         memset(&query, 0, sizeof(struct refspec));
 249         query.dst = tracking_branch;
 250         return !remote_find_tracking(remote, &query);
 251 }
 252
 253 static int validate_remote_tracking_branch(char *ref)
 254 {
 255         return !for_each_remote(check_tracking_branch, ref);
 256 }
 257
 258 static const char upstream_not_branch[] =
 259 N_("Cannot setup tracking information; starting point '%s' is not a branch.");
 260 static const char upstream_missing[] =
 261 N_("the requested upstream branch '%s' does not exist");
 262 static const char upstream_advice[] =
 263 N_("\n"
 264 "If you are planning on basing your work on an upstream\n"
 265 "branch that already exists at the remote, you may need to\n"
 266 "run \"git fetch\" to retrieve it.\n"
 267 "\n"
 268 "If you are planning to push out a new local branch that\n"
 269 "will track its remote counterpart, you may want to use\n"
 270 "\"git push -u\" to set the upstream config as you push.");
 271
 272 void create_branch(const char *head,
 273                    const char *name, const char *start_name,
 274                    int force, int reflog, int clobber_head,
 275                    int quiet, enum branch_track track)
 276 {
 277         struct ref_lock *lock = NULL;
 278         struct commit *commit;
 279         unsigned char sha1[20];
 280         char *real_ref, msg[PATH_MAX + 20];
 281         struct strbuf ref = STRBUF_INIT;
 282         int forcing = 0;
 283         int dont_change_ref = 0;
 284         int explicit_tracking = 0;
 285
 286         if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
 287                 explicit_tracking = 1;
 288
 289         if (validate_new_branchname(name, &ref, force,
 290                                     track == BRANCH_TRACK_OVERRIDE ||
 291                                     clobber_head)) {
 292                 if (!force)
 293                         dont_change_ref = 1;
 294                 else
 295                         forcing = 1;
 296         }
 297
 298         real_ref = NULL;
 299         if (get_sha1(start_name, sha1)) {
 300                 if (explicit_tracking) {
 301                         if (advice_set_upstream_failure) {
 302                                 error(_(upstream_missing), start_name);
 303                                 advise(_(upstream_advice));
 304                                 exit(1);
 305                         }
 306                         die(_(upstream_missing), start_name);
 307                 }
 308                 die(_("Not a valid object name: '%s'."), start_name);
 309         }
 310
 311         switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {
 312         case 0:
 313                 /* Not branching from any existing branch */
 314                 if (explicit_tracking)
 315                         die(_(upstream_not_branch), start_name);
 316                 break;
 317         case 1:
 318                 /* Unique completion -- good, only if it is a real branch */
 319                 if (!starts_with(real_ref, "refs/heads/") &&
 320                     validate_remote_tracking_branch(real_ref)) {
 321                         if (explicit_tracking)
 322                                 die(_(upstream_not_branch), start_name);
 323                         else
 324                                 real_ref = NULL;
 325                 }
 326                 break;
 327         default:
 328                 die(_("Ambiguous object name: '%s'."), start_name);
 329                 break;
 330         }
 331
 332         if ((commit = lookup_commit_reference(sha1)) == NULL)
 333                 die(_("Not a valid branch point: '%s'."), start_name);
 334         hashcpy(sha1, commit->object.sha1);
 335
 336         if (!dont_change_ref) {
 337                 lock = lock_any_ref_for_update(ref.buf, NULL, 0, NULL);
 338                 if (!lock)
 339                         die_errno(_("Failed to lock ref for update"));
 340         }
 341
 342         if (reflog)
 343                 log_all_ref_updates = 1;
 344
 345         if (forcing)
 346                 snprintf(msg, sizeof msg, "branch: Reset to %s",
 347                          start_name);
 348         else if (!dont_change_ref)
 349                 snprintf(msg, sizeof msg, "branch: Created from %s",
 350                          start_name);
 351
 352         if (real_ref && track)
 353                 setup_tracking(ref.buf + 11, real_ref, track, quiet);
 354
 355         if (!dont_change_ref)
 356                 if (write_ref_sha1(lock, sha1, msg) < 0)
 357                         die_errno(_("Failed to write ref"));
 358
 359         strbuf_release(&ref);
 360         free(real_ref);
 361 }
 362
 363 void remove_branch_state(void)
 364 {
 365         unlink(git_path("CHERRY_PICK_HEAD"));
 366         unlink(git_path("REVERT_HEAD"));
 367         unlink(git_path("MERGE_HEAD"));
 368         unlink(git_path("MERGE_RR"));
 369         unlink(git_path("MERGE_MSG"));
 370         unlink(git_path("MERGE_MODE"));
 371         unlink(git_path("SQUASH_MSG"));
 372 }