refs: break out ref conflict checks

Create new function find_descendant_ref, to hold one of the ref
conflict checks used in verify_refname_available. Multiple backends
will need this function, so move it to the common code.

Also move rename_ref_available to the common code, because alternate
backends might need it and it has no files-backend-specific code.

Signed-off-by: David Turner <dturner@twopensource.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Jeff King <peff@peff.net>

diff --git a/refs.c b/refs.c
index 1620a53..ad883ec 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -1029,3 +1029,47 @@ int ref_is_hidden(const char *refname)
        }
        return 0;
 }
+
+const char *find_descendant_ref(const char *dirname,
+                               const struct string_list *extras,
+                               const struct string_list *skip)
+{
+       int pos;
+
+       if (!extras)
+               return NULL;
+
+       /*
+        * Look at the place where dirname would be inserted into
+        * extras. If there is an entry at that position that starts
+        * with dirname (remember, dirname includes the trailing
+        * slash) and is not in skip, then we have a conflict.
+        */
+       for (pos = string_list_find_insert_index(extras, dirname, 0);
+            pos < extras->nr; pos++) {
+               const char *extra_refname = extras->items[pos].string;
+
+               if (!starts_with(extra_refname, dirname))
+                       break;
+
+               if (!skip || !string_list_has_string(skip, extra_refname))
+                       return extra_refname;
+       }
+       return NULL;
+}
+
+int rename_ref_available(const char *oldname, const char *newname)
+{
+       struct string_list skip = STRING_LIST_INIT_NODUP;
+       struct strbuf err = STRBUF_INIT;
+       int ret;
+
+       string_list_insert(&skip, oldname);
+       ret = !verify_refname_available(newname, NULL, &skip, &err);
+       if (!ret)
+               error("%s", err.buf);
+
+       string_list_clear(&skip, 0);
+       strbuf_release(&err);
+       return ret;
+}

diff --git a/refs/files-backend.c b/refs/files-backend.c
index aaf2639..4db3e36 100644 (file)
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -728,6 +728,7 @@ static int verify_refname_available_dir(const char *refname,
                                        struct strbuf *err)
 {
        const char *slash;
+       const char *extra_refname;
        int pos;
        struct strbuf dirname = STRBUF_INIT;
        int ret = -1;
@@ -833,32 +834,12 @@ static int verify_refname_available_dir(const char *refname,
                }
        }
 
-       if (extras) {
-               /*
-                * Check for entries in extras that start with
-                * "$refname/". We do that by looking for the place
-                * where "$refname/" would be inserted in extras. If
-                * there is an entry at that position that starts with
-                * "$refname/" and is not in skip, then we have a
-                * conflict.
-                */
-               for (pos = string_list_find_insert_index(extras, dirname.buf, 0);
-                    pos < extras->nr; pos++) {
-                       const char *extra_refname = extras->items[pos].string;
-
-                       if (!starts_with(extra_refname, dirname.buf))
-                               break;
-
-                       if (!skip || !string_list_has_string(skip, extra_refname)) {
-                               strbuf_addf(err, "cannot process '%s' and '%s' at the same time",
-                                           refname, extra_refname);
-                               goto cleanup;
-                       }
-               }
-       }
-
-       /* No conflicts were found */
-       ret = 0;
+       extra_refname = find_descendant_ref(dirname.buf, extras, skip);
+       if (extra_refname)
+               strbuf_addf(err, "cannot process '%s' and '%s' at the same time",
+                           refname, extra_refname);
+       else
+               ret = 0;
 
 cleanup:
        strbuf_release(&dirname);
@@ -2473,22 +2454,6 @@ int verify_refname_available(const char *newname,
        return 0;
 }
 
-static int rename_ref_available(const char *oldname, const char *newname)
-{
-       struct string_list skip = STRING_LIST_INIT_NODUP;
-       struct strbuf err = STRBUF_INIT;
-       int ret;
-
-       string_list_insert(&skip, oldname);
-       ret = !verify_refname_available(newname, NULL, &skip, &err);
-       if (!ret)
-               error("%s", err.buf);
-
-       string_list_clear(&skip, 0);
-       strbuf_release(&err);
-       return ret;
-}
-
 static int write_ref_to_lockfile(struct ref_lock *lock,
                                 const unsigned char *sha1, struct strbuf *err);
 static int commit_ref_update(struct ref_lock *lock,

diff --git a/refs/refs-internal.h b/refs/refs-internal.h
index 7b6c8bc..c7dded3 100644 (file)
--- a/refs/refs-internal.h
+++ b/refs/refs-internal.h
@@ -181,4 +181,20 @@ int files_log_ref_write(const char *refname, const unsigned char *old_sha1,
                        const unsigned char *new_sha1, const char *msg,
                        int flags, struct strbuf *err);
 
+/*
+ * Check for entries in extras that are within the specified
+ * directory, where dirname is a reference directory name including
+ * the trailing slash (e.g., "refs/heads/foo/"). Ignore any
+ * conflicting references that are found in skip. If there is a
+ * conflicting reference, return its name.
+ *
+ * extras and skip must be sorted lists of reference names. Either one
+ * can be NULL, signifying the empty list.
+ */
+const char *find_descendant_ref(const char *dirname,
+                               const struct string_list *extras,
+                               const struct string_list *skip);
+
+int rename_ref_available(const char *oldname, const char *newname);
+
 #endif /* REFS_REFS_INTERNAL_H */