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.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 void install_branch_base(const char *local, const unsigned char *tail)
 107 {
 108         struct strbuf ref = STRBUF_INIT;
 109
 110         strbuf_addf(&ref, "refs/tails/%s", local);
 111         update_ref(NULL, ref.buf, tail, NULL, 0, MSG_ON_ERR);
 112
 113         strbuf_release(&ref);
 114 }
 115
 116 /*
 117  * This is called when new_ref is branched off of orig_ref, and tries
 118  * to infer the settings for branch.<new_ref>.{remote,merge} from the
 119  * config.
 120  */
 121 static int setup_tracking(const char *new_ref, const char *orig_ref,
 122                           enum branch_track track, int quiet)
 123 {
 124         struct tracking tracking;
 125         int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;
 126
 127         if (strlen(new_ref) > 1024 - 7 - 7 - 1)
 128                 return error(_("Tracking not set up: name too long: %s"),
 129                                 new_ref);
 130
 131         memset(&tracking, 0, sizeof(tracking));
 132         tracking.spec.dst = (char *)orig_ref;
 133         if (for_each_remote(find_tracked_branch, &tracking))
 134                 return 1;
 135
 136         if (!tracking.matches)
 137                 switch (track) {
 138                 case BRANCH_TRACK_ALWAYS:
 139                 case BRANCH_TRACK_EXPLICIT:
 140                 case BRANCH_TRACK_OVERRIDE:
 141                         break;
 142                 default:
 143                         return 1;
 144                 }
 145
 146         if (tracking.matches > 1)
 147                 return error(_("Not tracking: ambiguous information for ref %s"),
 148                                 orig_ref);
 149
 150         install_branch_config(config_flags, new_ref, tracking.remote,
 151                               tracking.src ? tracking.src : orig_ref);
 152
 153         free(tracking.src);
 154         return 0;
 155 }
 156
 157 struct branch_desc_cb {
 158         const char *config_name;
 159         const char *value;
 160 };
 161
 162 static int read_branch_desc_cb(const char *var, const char *value, void *cb)
 163 {
 164         struct branch_desc_cb *desc = cb;
 165         if (strcmp(desc->config_name, var))
 166                 return 0;
 167         free((char *)desc->value);
 168         return git_config_string(&desc->value, var, value);
 169 }
 170
 171 int read_branch_desc(struct strbuf *buf, const char *branch_name)
 172 {
 173         struct branch_desc_cb cb;
 174         struct strbuf name = STRBUF_INIT;
 175         strbuf_addf(&name, "branch.%s.description", branch_name);
 176         cb.config_name = name.buf;
 177         cb.value = NULL;
 178         if (git_config(read_branch_desc_cb, &cb) < 0) {
 179                 strbuf_release(&name);
 180                 return -1;
 181         }
 182         if (cb.value)
 183                 strbuf_addstr(buf, cb.value);
 184         strbuf_release(&name);
 185         return 0;
 186 }
 187
 188 int validate_new_branchname(const char *name, struct strbuf *ref,
 189                             int force, int attr_only)
 190 {
 191         if (strbuf_check_branch_ref(ref, name))
 192                 die(_("'%s' is not a valid branch name."), name);
 193
 194         if (!ref_exists(ref->buf))
 195                 return 0;
 196         else if (!force && !attr_only)
 197                 die(_("A branch named '%s' already exists."), ref->buf + strlen("refs/heads/"));
 198
 199         if (!attr_only) {
 200                 const char *head;
 201                 unsigned char sha1[20];
 202
 203                 head = resolve_ref_unsafe("HEAD", sha1, 0, NULL);
 204                 if (!is_bare_repository() && head && !strcmp(head, ref->buf))
 205                         die(_("Cannot force update the current branch."));
 206         }
 207         return 1;
 208 }
 209
 210 static int check_tracking_branch(struct remote *remote, void *cb_data)
 211 {
 212         char *tracking_branch = cb_data;
 213         struct refspec query;
 214         memset(&query, 0, sizeof(struct refspec));
 215         query.dst = tracking_branch;
 216         return !remote_find_tracking(remote, &query);
 217 }
 218
 219 static int validate_remote_tracking_branch(char *ref)
 220 {
 221         return !for_each_remote(check_tracking_branch, ref);
 222 }
 223
 224 static const char upstream_not_branch[] =
 225 N_("Cannot setup tracking information; starting point '%s' is not a branch.");
 226 static const char upstream_missing[] =
 227 N_("the requested upstream branch '%s' does not exist");
 228 static const char upstream_advice[] =
 229 N_("\n"
 230 "If you are planning on basing your work on an upstream\n"
 231 "branch that already exists at the remote, you may need to\n"
 232 "run \"git fetch\" to retrieve it.\n"
 233 "\n"
 234 "If you are planning to push out a new local branch that\n"
 235 "will track its remote counterpart, you may want to use\n"
 236 "\"git push -u\" to set the upstream config as you push.");
 237
 238 void create_branch(const char *head,
 239                    const char *name, const char *start_name,
 240                    int force, int reflog, int clobber_head,
 241                    int quiet, enum branch_track track)
 242 {
 243         struct ref_lock *lock = NULL;
 244         struct commit *commit;
 245         unsigned char sha1[20];
 246         char *real_ref, msg[PATH_MAX + 20];
 247         struct strbuf ref = STRBUF_INIT;
 248         int forcing = 0;
 249         int dont_change_ref = 0;
 250         int explicit_tracking = 0;
 251
 252         if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
 253                 explicit_tracking = 1;
 254
 255         if (validate_new_branchname(name, &ref, force,
 256                                     track == BRANCH_TRACK_OVERRIDE ||
 257                                     clobber_head)) {
 258                 if (!force)
 259                         dont_change_ref = 1;
 260                 else
 261                         forcing = 1;
 262         }
 263
 264         real_ref = NULL;
 265         if (get_sha1(start_name, sha1)) {
 266                 if (explicit_tracking) {
 267                         if (advice_set_upstream_failure) {
 268                                 error(_(upstream_missing), start_name);
 269                                 advise(_(upstream_advice));
 270                                 exit(1);
 271                         }
 272                         die(_(upstream_missing), start_name);
 273                 }
 274                 die(_("Not a valid object name: '%s'."), start_name);
 275         }
 276
 277         switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {
 278         case 0:
 279                 /* Not branching from any existing branch */
 280                 if (explicit_tracking)
 281                         die(_(upstream_not_branch), start_name);
 282                 break;
 283         case 1:
 284                 /* Unique completion -- good, only if it is a real branch */
 285                 if (!starts_with(real_ref, "refs/heads/") &&
 286                     validate_remote_tracking_branch(real_ref)) {
 287                         if (explicit_tracking)
 288                                 die(_(upstream_not_branch), start_name);
 289                         else
 290                                 real_ref = NULL;
 291                 }
 292                 break;
 293         default:
 294                 die(_("Ambiguous object name: '%s'."), start_name);
 295                 break;
 296         }
 297
 298         if ((commit = lookup_commit_reference(sha1)) == NULL)
 299                 die(_("Not a valid branch point: '%s'."), start_name);
 300         hashcpy(sha1, commit->object.sha1);
 301
 302         if (!dont_change_ref) {
 303                 lock = lock_any_ref_for_update(ref.buf, NULL, 0, NULL);
 304                 if (!lock)
 305                         die_errno(_("Failed to lock ref for update"));
 306         }
 307
 308         if (reflog)
 309                 log_all_ref_updates = 1;
 310
 311         if (forcing)
 312                 snprintf(msg, sizeof msg, "branch: Reset to %s",
 313                          start_name);
 314         else if (!dont_change_ref)
 315                 snprintf(msg, sizeof msg, "branch: Created from %s",
 316                          start_name);
 317
 318         if (real_ref && track)
 319                 setup_tracking(ref.buf + 11, real_ref, track, quiet);
 320
 321         install_branch_base(ref.buf + 11, sha1);
 322
 323         if (!dont_change_ref)
 324                 if (write_ref_sha1(lock, sha1, msg) < 0)
 325                         die_errno(_("Failed to write ref"));
 326
 327         strbuf_release(&ref);
 328         free(real_ref);
 329 }
 330
 331 void remove_branch_state(void)
 332 {
 333         unlink(git_path("CHERRY_PICK_HEAD"));
 334         unlink(git_path("REVERT_HEAD"));
 335         unlink(git_path("MERGE_HEAD"));
 336         unlink(git_path("MERGE_RR"));
 337         unlink(git_path("MERGE_MSG"));
 338         unlink(git_path("MERGE_MODE"));
 339         unlink(git_path("SQUASH_MSG"));
 340 }