push: rename config variable for more general use

diff --git a/remote.c b/remote.c
index 012b52f6fd5aa892894b09bc38109155ad0d6810..aa6b7199b7c0a5abec5dfb697fef6f03f2b419b2 100644 (file)
--- a/remote.c
+++ b/remote.c
@@ -1281,9 +1281,21 @@ int match_push_refs(struct ref *src, struct ref **dst,
 
 static inline int is_forwardable(struct ref* ref)
 {
+       struct object *o;
+
        if (!prefixcmp(ref->name, "refs/tags/"))
                return 0;
 
+       /* old object must be a commit */
+       o = parse_object(ref->old_sha1);
+       if (!o || o->type != OBJ_COMMIT)
+               return 0;
+
+       /* new object must be commit-ish */
+       o = deref_tag(parse_object(ref->new_sha1), NULL, 0);
+       if (!o || o->type != OBJ_COMMIT)
+               return 0;
+
        return 1;
 }
 
@@ -1307,27 +1319,29 @@ void set_ref_status_for_push(struct ref *remote_refs, int send_mirror,
                        continue;
                }
 
-               /* This part determines what can overwrite what.
-                * The rules are:
+               /*
+                * The below logic determines whether an individual
+                * refspec A:B can be pushed.  The push will succeed
+                * if any of the following are true:
                 *
-                * (0) you can always use --force or +A:B notation to
-                *     selectively force individual ref pairs.
+                * (1) the remote reference B does not exist
                 *
-                * (1) if the old thing does not exist, it is OK.
+                * (2) the remote reference B is being removed (i.e.,
+                *     pushing :B where no source is specified)
                 *
-                * (2) if the destination is under refs/tags/ you are
-                *     not allowed to overwrite it; tags are expected
-                *     to be static once created
+                * (3) the update meets all fast-forwarding criteria:
                 *
-                * (3) if you do not have the old thing, you are not allowed
-                *     to overwrite it; you would not know what you are losing
-                *     otherwise.
+                *     (a) the destination is not under refs/tags/
+                *     (b) the old is a commit
+                *     (c) the new is a descendant of the old
                 *
-                * (4) if both new and old are commit-ish, and new is a
-                *     descendant of old, it is OK.
+                *     NOTE: We must actually have the old object in
+                *     order to overwrite it in the remote reference,
+                *     and the new object must be commit-ish.  These are
+                *     implied by (b) and (c) respectively.
                 *
-                * (5) regardless of all of the above, removing :B is
-                *     always allowed.
+                * (4) it is forced using the +A:B notation, or by
+                *     passing the --force argument
                 */
 
                ref->not_forwardable = !is_forwardable(ref);