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