Andrew's git - gitweb.git/blob

   1#include "cache.h"
   2#include "branch.h"
   3#include "refs.h"
   4#include "remote.h"
   5#include "commit.h"
   6
   7struct tracking {
   8        struct refspec spec;
   9        char *src;
  10        const char *remote;
  11        int matches;
  12};
  13
  14static 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
  35static 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
  50void 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 */
 111static 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
 147struct branch_desc_cb {
 148        const char *config_name;
 149        const char *value;
 150};
 151
 152static 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
 161int 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
 178int 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
 200static 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
 209static int validate_remote_tracking_branch(char *ref)
 210{
 211        return !for_each_remote(check_tracking_branch, ref);
 212}
 213
 214static const char upstream_not_branch[] =
 215N_("Cannot setup tracking information; starting point '%s' is not a branch.");
 216static const char upstream_missing[] =
 217N_("the requested upstream branch '%s' does not exist");
 218static const char upstream_advice[] =
 219N_("\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
 228void 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
 319void 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}