Merge branch 'db/maint-missing-origin'
authorJunio C Hamano <gitster@pobox.com>
Wed, 18 Mar 2009 01:58:41 +0000 (18:58 -0700)
committerJunio C Hamano <gitster@pobox.com>
Wed, 18 Mar 2009 01:58:41 +0000 (18:58 -0700)
* db/maint-missing-origin:
Remove total confusion from git-fetch and git-push
Give error when no remote is configured

1  2 
remote.c
diff --combined remote.c
index 7172835790de6e0ac27a19a14c22350e90cdab65,c7a8c2b1fbdea9aa03d8a5ccd8cbfb39eed742df..baa50aab6573738059a9a71a224acb6877257255
+++ b/remote.c
@@@ -5,7 -5,6 +5,7 @@@
  #include "diff.h"
  #include "revision.h"
  #include "dir.h"
 +#include "tag.h"
  
  static struct refspec s_tag_refspec = {
        0,
@@@ -39,6 -38,7 +39,7 @@@ static int branches_nr
  
  static struct branch *current_branch;
  static const char *default_remote_name;
+ static int explicit_default_remote_name;
  
  static struct rewrite **rewrite;
  static int rewrite_alloc;
@@@ -331,8 -331,10 +332,10 @@@ static int handle_config(const char *ke
                        if (!value)
                                return config_error_nonbool(key);
                        branch->remote_name = xstrdup(value);
-                       if (branch == current_branch)
+                       if (branch == current_branch) {
                                default_remote_name = branch->remote_name;
+                               explicit_default_remote_name = 1;
+                       }
                } else if (!strcmp(subkey, ".merge")) {
                        if (!value)
                                return config_error_nonbool(key);
@@@ -496,7 -498,7 +499,7 @@@ static struct refspec *parse_refspec_in
                int is_glob;
                const char *lhs, *rhs;
  
 -              llen = is_glob = 0;
 +              is_glob = 0;
  
                lhs = refspec[i];
                if (*lhs == '+') {
@@@ -644,10 -646,16 +647,16 @@@ static int valid_remote_nick(const cha
  struct remote *remote_get(const char *name)
  {
        struct remote *ret;
+       int name_given = 0;
  
        read_config();
-       if (!name)
+       if (name)
+               name_given = 1;
+       else {
                name = default_remote_name;
+               name_given = explicit_default_remote_name;
+       }
        ret = make_remote(name, 0);
        if (valid_remote_nick(name)) {
                if (!ret->url)
                if (!ret->url)
                        read_branches_file(ret);
        }
-       if (!ret->url)
+       if (name_given && !ret->url)
                add_url_alias(ret, name);
        if (!ret->url)
                return NULL;
@@@ -779,18 -787,10 +788,18 @@@ struct ref *alloc_ref(const char *name
  
  static struct ref *copy_ref(const struct ref *ref)
  {
 -      struct ref *ret = xmalloc(sizeof(struct ref) + strlen(ref->name) + 1);
 -      memcpy(ret, ref, sizeof(struct ref) + strlen(ref->name) + 1);
 -      ret->next = NULL;
 -      return ret;
 +      struct ref *cpy;
 +      size_t len;
 +      if (!ref)
 +              return NULL;
 +      len = strlen(ref->name);
 +      cpy = xmalloc(sizeof(struct ref) + len + 1);
 +      memcpy(cpy, ref, sizeof(struct ref) + len + 1);
 +      cpy->next = NULL;
 +      cpy->symref = ref->symref ? xstrdup(ref->symref) : NULL;
 +      cpy->remote_status = ref->remote_status ? xstrdup(ref->remote_status) : NULL;
 +      cpy->peer_ref = copy_ref(ref->peer_ref);
 +      return cpy;
  }
  
  struct ref *copy_ref_list(const struct ref *ref)
@@@ -809,7 -809,6 +818,7 @@@ static void free_ref(struct ref *ref
  {
        if (!ref)
                return;
 +      free_ref(ref->peer_ref);
        free(ref->remote_status);
        free(ref->symref);
        free(ref);
@@@ -820,6 -819,7 +829,6 @@@ void free_refs(struct ref *ref
        struct ref *next;
        while (ref) {
                next = ref->next;
 -              free(ref->peer_ref);
                free_ref(ref);
                ref = next;
        }
@@@ -936,7 -936,6 +945,7 @@@ static int match_explicit(struct ref *s
                          struct refspec *rs)
  {
        struct ref *matched_src, *matched_dst;
 +      int copy_src;
  
        const char *dst_value = rs->dst;
        char *dst_guess;
        matched_src = matched_dst = NULL;
        switch (count_refspec_match(rs->src, src, &matched_src)) {
        case 1:
 +              copy_src = 1;
                break;
        case 0:
                /* The source could be in the get_sha1() format
                matched_src = try_explicit_object_name(rs->src);
                if (!matched_src)
                        return error("src refspec %s does not match any.", rs->src);
 +              copy_src = 0;
                break;
        default:
                return error("src refspec %s matches more than one.", rs->src);
                return error("dst ref %s receives from more than one src.",
                      matched_dst->name);
        else {
 -              matched_dst->peer_ref = matched_src;
 +              matched_dst->peer_ref = copy_src ? copy_ref(matched_src) : matched_src;
                matched_dst->force = rs->force;
        }
        return 0;
@@@ -1052,7 -1049,6 +1061,7 @@@ int match_refs(struct ref *src, struct 
        struct refspec *rs;
        int send_all = flags & MATCH_REFS_ALL;
        int send_mirror = flags & MATCH_REFS_MIRROR;
 +      int errs;
        static const char *default_refspec[] = { ":", 0 };
  
        if (!nr_refspec) {
                refspec = default_refspec;
        }
        rs = parse_push_refspec(nr_refspec, (const char **) refspec);
 -      if (match_explicit_refs(src, dst, dst_tail, rs, nr_refspec))
 -              return -1;
 +      errs = match_explicit_refs(src, dst, dst_tail, rs, nr_refspec);
  
        /* pick the remainder */
        for ( ; src; src = src->next) {
                        dst_peer = make_linked_ref(dst_name, dst_tail);
                        hashcpy(dst_peer->new_sha1, src->new_sha1);
                }
 -              dst_peer->peer_ref = src;
 +              dst_peer->peer_ref = copy_ref(src);
                dst_peer->force = pat->force;
        free_name:
                free(dst_name);
        }
 +      if (errs)
 +              return -1;
        return 0;
  }
  
@@@ -1283,54 -1278,6 +1292,54 @@@ int resolve_remote_symref(struct ref *r
        return 1;
  }
  
 +static void unmark_and_free(struct commit_list *list, unsigned int mark)
 +{
 +      while (list) {
 +              struct commit_list *temp = list;
 +              temp->item->object.flags &= ~mark;
 +              list = temp->next;
 +              free(temp);
 +      }
 +}
 +
 +int ref_newer(const unsigned char *new_sha1, const unsigned char *old_sha1)
 +{
 +      struct object *o;
 +      struct commit *old, *new;
 +      struct commit_list *list, *used;
 +      int found = 0;
 +
 +      /* Both new and old must be commit-ish and new is descendant of
 +       * old.  Otherwise we require --force.
 +       */
 +      o = deref_tag(parse_object(old_sha1), NULL, 0);
 +      if (!o || o->type != OBJ_COMMIT)
 +              return 0;
 +      old = (struct commit *) o;
 +
 +      o = deref_tag(parse_object(new_sha1), NULL, 0);
 +      if (!o || o->type != OBJ_COMMIT)
 +              return 0;
 +      new = (struct commit *) o;
 +
 +      if (parse_commit(new) < 0)
 +              return 0;
 +
 +      used = list = NULL;
 +      commit_list_insert(new, &list);
 +      while (list) {
 +              new = pop_most_recent_commit(&list, TMP_MARK);
 +              commit_list_insert(new, &used);
 +              if (new == old) {
 +                      found = 1;
 +                      break;
 +              }
 +      }
 +      unmark_and_free(list, TMP_MARK);
 +      unmark_and_free(used, TMP_MARK);
 +      return found;
 +}
 +
  /*
   * Return true if there is anything to report, otherwise false.
   */
@@@ -1438,68 -1385,3 +1447,68 @@@ int format_tracking_info(struct branch 
                            base, num_ours, num_theirs);
        return 1;
  }
 +
 +static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 +{
 +      struct ref ***local_tail = cb_data;
 +      struct ref *ref;
 +      int len;
 +
 +      /* we already know it starts with refs/ to get here */
 +      if (check_ref_format(refname + 5))
 +              return 0;
 +
 +      len = strlen(refname) + 1;
 +      ref = xcalloc(1, sizeof(*ref) + len);
 +      hashcpy(ref->new_sha1, sha1);
 +      memcpy(ref->name, refname, len);
 +      **local_tail = ref;
 +      *local_tail = &ref->next;
 +      return 0;
 +}
 +
 +struct ref *get_local_heads(void)
 +{
 +      struct ref *local_refs, **local_tail = &local_refs;
 +      for_each_ref(one_local_ref, &local_tail);
 +      return local_refs;
 +}
 +
 +struct ref *guess_remote_head(const struct ref *head,
 +                            const struct ref *refs,
 +                            int all)
 +{
 +      const struct ref *r;
 +      struct ref *list = NULL;
 +      struct ref **tail = &list;
 +
 +      if (!head)
 +              return NULL;
 +
 +      /*
 +       * Some transports support directly peeking at
 +       * where HEAD points; if that is the case, then
 +       * we don't have to guess.
 +       */
 +      if (head->symref)
 +              return copy_ref(find_ref_by_name(refs, head->symref));
 +
 +      /* If refs/heads/master could be right, it is. */
 +      if (!all) {
 +              r = find_ref_by_name(refs, "refs/heads/master");
 +              if (r && !hashcmp(r->old_sha1, head->old_sha1))
 +                      return copy_ref(r);
 +      }
 +
 +      /* Look for another ref that points there */
 +      for (r = refs; r; r = r->next) {
 +              if (r != head && !hashcmp(r->old_sha1, head->old_sha1)) {
 +                      *tail = copy_ref(r);
 +                      tail = &((*tail)->next);
 +                      if (!all)
 +                              break;
 +              }
 +      }
 +
 +      return list;
 +}