Merge branch 'lv/add-doc-working-tree' into maint

diff --git a/refs/files-backend.c b/refs/files-backend.c
index aaf263956c97463915860b3fcdbd2ff7b110b6db..3a27f275859acbe1afe516e4165f600b900f634a 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);
@@ -952,6 +933,10 @@ static void clear_loose_ref_cache(struct ref_cache *refs)
        }
 }
 
+/*
+ * Create a new submodule ref cache and add it to the internal
+ * set of caches.
+ */
 static struct ref_cache *create_ref_cache(const char *submodule)
 {
        int len;
@@ -961,16 +946,12 @@ static struct ref_cache *create_ref_cache(const char *submodule)
        len = strlen(submodule) + 1;
        refs = xcalloc(1, sizeof(struct ref_cache) + len);
        memcpy(refs->name, submodule, len);
+       refs->next = submodule_ref_caches;
+       submodule_ref_caches = refs;
        return refs;
 }
 
-/*
- * Return a pointer to a ref_cache for the specified submodule. For
- * the main repository, use submodule==NULL. The returned structure
- * will be allocated and initialized but not necessarily populated; it
- * should not be freed.
- */
-static struct ref_cache *get_ref_cache(const char *submodule)
+static struct ref_cache *lookup_ref_cache(const char *submodule)
 {
        struct ref_cache *refs;
 
@@ -980,10 +961,20 @@ static struct ref_cache *get_ref_cache(const char *submodule)
        for (refs = submodule_ref_caches; refs; refs = refs->next)
                if (!strcmp(submodule, refs->name))
                        return refs;
+       return NULL;
+}
 
-       refs = create_ref_cache(submodule);
-       refs->next = submodule_ref_caches;
-       submodule_ref_caches = refs;
+/*
+ * Return a pointer to a ref_cache for the specified submodule. For
+ * the main repository, use submodule==NULL. The returned structure
+ * will be allocated and initialized but not necessarily populated; it
+ * should not be freed.
+ */
+static struct ref_cache *get_ref_cache(const char *submodule)
+{
+       struct ref_cache *refs = lookup_ref_cache(submodule);
+       if (!refs)
+               refs = create_ref_cache(submodule);
        return refs;
 }
 
@@ -1355,16 +1346,24 @@ static int resolve_gitlink_ref_recursive(struct ref_cache *refs,
 int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)
 {
        int len = strlen(path), retval;
-       char *submodule;
+       struct strbuf submodule = STRBUF_INIT;
        struct ref_cache *refs;
 
        while (len && path[len-1] == '/')
                len--;
        if (!len)
                return -1;
-       submodule = xstrndup(path, len);
-       refs = get_ref_cache(submodule);
-       free(submodule);
+
+       strbuf_add(&submodule, path, len);
+       refs = lookup_ref_cache(submodule.buf);
+       if (!refs) {
+               if (!is_nonbare_repository_dir(&submodule)) {
+                       strbuf_release(&submodule);
+                       return -1;
+               }
+               refs = create_ref_cache(submodule.buf);
+       }
+       strbuf_release(&submodule);
 
        retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);
        return retval;
@@ -2473,22 +2472,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,
@@ -3529,7 +3512,7 @@ int reflog_expire(const char *refname, const unsigned char *sha1,
                                        get_lock_file_path(lock->lk));
                        rollback_lock_file(&reflog_lock);
                } else if (commit_lock_file(&reflog_lock)) {
-                       status |= error("unable to commit reflog '%s' (%s)",
+                       status |= error("unable to write reflog '%s' (%s)",
                                        log_file, strerror(errno));
                } else if (update && commit_ref(lock)) {
                        status |= error("couldn't set %s", lock->ref_name);