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 struct tracking *tracking)
  36{
  37        switch (autorebase) {
  38        case AUTOREBASE_NEVER:
  39                return 0;
  40        case AUTOREBASE_LOCAL:
  41                return tracking->remote == NULL;
  42        case AUTOREBASE_REMOTE:
  43                return tracking->remote != NULL;
  44        case AUTOREBASE_ALWAYS:
  45                return 1;
  46        }
  47        return 0;
  48}
  49
  50/*
  51 * This is called when new_ref is branched off of orig_ref, and tries
  52 * to infer the settings for branch.<new_ref>.{remote,merge} from the
  53 * config.
  54 */
  55static int setup_tracking(const char *new_ref, const char *orig_ref,
  56                          enum branch_track track)
  57{
  58        char key[1024];
  59        struct tracking tracking;
  60
  61        if (strlen(new_ref) > 1024 - 7 - 7 - 1)
  62                return error("Tracking not set up: name too long: %s",
  63                                new_ref);
  64
  65        memset(&tracking, 0, sizeof(tracking));
  66        tracking.spec.dst = (char *)orig_ref;
  67        if (for_each_remote(find_tracked_branch, &tracking))
  68                return 1;
  69
  70        if (!tracking.matches)
  71                switch (track) {
  72                case BRANCH_TRACK_ALWAYS:
  73                case BRANCH_TRACK_EXPLICIT:
  74                        break;
  75                default:
  76                        return 1;
  77                }
  78
  79        if (tracking.matches > 1)
  80                return error("Not tracking: ambiguous information for ref %s",
  81                                orig_ref);
  82
  83        sprintf(key, "branch.%s.remote", new_ref);
  84        git_config_set(key, tracking.remote ?  tracking.remote : ".");
  85        sprintf(key, "branch.%s.merge", new_ref);
  86        git_config_set(key, tracking.src ? tracking.src : orig_ref);
  87        printf("Branch %s set up to track %s branch %s.\n", new_ref,
  88                tracking.remote ? "remote" : "local", orig_ref);
  89        if (should_setup_rebase(&tracking)) {
  90                sprintf(key, "branch.%s.rebase", new_ref);
  91                git_config_set(key, "true");
  92                printf("This branch will rebase on pull.\n");
  93        }
  94        free(tracking.src);
  95
  96        return 0;
  97}
  98
  99void create_branch(const char *head,
 100                   const char *name, const char *start_name,
 101                   int force, int reflog, enum branch_track track)
 102{
 103        struct ref_lock *lock;
 104        struct commit *commit;
 105        unsigned char sha1[20];
 106        char *real_ref, ref[PATH_MAX], msg[PATH_MAX + 20];
 107        int forcing = 0;
 108
 109        snprintf(ref, sizeof ref, "refs/heads/%s", name);
 110        if (check_ref_format(ref))
 111                die("'%s' is not a valid branch name.", name);
 112
 113        if (resolve_ref(ref, sha1, 1, NULL)) {
 114                if (!force)
 115                        die("A branch named '%s' already exists.", name);
 116                else if (!is_bare_repository() && !strcmp(head, name))
 117                        die("Cannot force update the current branch.");
 118                forcing = 1;
 119        }
 120
 121        real_ref = NULL;
 122        if (get_sha1(start_name, sha1))
 123                die("Not a valid object name: '%s'.", start_name);
 124
 125        switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {
 126        case 0:
 127                /* Not branching from any existing branch */
 128                if (track == BRANCH_TRACK_EXPLICIT)
 129                        die("Cannot setup tracking information; starting point is not a branch.");
 130                break;
 131        case 1:
 132                /* Unique completion -- good, only if it is a real ref */
 133                if (track == BRANCH_TRACK_EXPLICIT && !strcmp(real_ref, "HEAD"))
 134                        die("Cannot setup tracking information; starting point is not a branch.");
 135                break;
 136        default:
 137                die("Ambiguous object name: '%s'.", start_name);
 138                break;
 139        }
 140
 141        if ((commit = lookup_commit_reference(sha1)) == NULL)
 142                die("Not a valid branch point: '%s'.", start_name);
 143        hashcpy(sha1, commit->object.sha1);
 144
 145        lock = lock_any_ref_for_update(ref, NULL, 0);
 146        if (!lock)
 147                die("Failed to lock ref for update: %s.", strerror(errno));
 148
 149        if (reflog)
 150                log_all_ref_updates = 1;
 151
 152        if (forcing)
 153                snprintf(msg, sizeof msg, "branch: Reset from %s",
 154                         start_name);
 155        else
 156                snprintf(msg, sizeof msg, "branch: Created from %s",
 157                         start_name);
 158
 159        if (real_ref && track)
 160                setup_tracking(name, real_ref, track);
 161
 162        if (write_ref_sha1(lock, sha1, msg) < 0)
 163                die("Failed to write ref: %s.", strerror(errno));
 164
 165        free(real_ref);
 166}
 167
 168void remove_branch_state(void)
 169{
 170        unlink(git_path("MERGE_HEAD"));
 171        unlink(git_path("MERGE_RR"));
 172        unlink(git_path("MERGE_MSG"));
 173        unlink(git_path("SQUASH_MSG"));
 174}