Changeset 782 for git/branches/dmik/builtin/clone.c

Timestamp:

Jun 23, 2014, 9:45:51 PM (11 years ago)

Author:

dmik

Message:

git: Merge version 2.0.0 from vendor to dmik branch.

Location:

git/branches/dmik

Files:

• . (modified) (1 prop)
• builtin/clone.c (modified) (25 diffs)

git/branches/dmik/builtin/clone.c ¶

@@ -19 +19 @@
 #include "strbuf.h"
 #include "dir.h"
-#include "pack-refs.h"
 #include "sigchain.h"
 #include "branch.h"
 #include "remote.h"
 #include "run-command.h"
+#include "connected.h"
 
 /*
@@ -34 +34 @@
  */
 static const char * const builtin_clone_usage[] = {
-        "git clone [options] [--] <repo> [<dir>]",
+        N_("git clone [options] [--] <repo> [<dir>]"),
         NULL
 };
 
-static int option_no_checkout, option_bare, option_mirror;
-static int option_local, option_no_hardlinks, option_shared, option_recursive;
+static int option_no_checkout, option_bare, option_mirror, option_single_branch = -1;
+static int option_local = -1, option_no_hardlinks, option_shared, option_recursive;
 static char *option_template, *option_depth;
 static char *option_origin = NULL;
@@ -62 +62 @@
         OPT__VERBOSITY(&option_verbosity),
         OPT_BOOL(0, "progress", &option_progress,
-                 "force progress reporting"),
-        OPT_BOOLEAN('n', "no-checkout", &option_no_checkout,
-                    "don't create a checkout"),
-        OPT_BOOLEAN(0, "bare", &option_bare, "create a bare repository"),
-        { OPTION_BOOLEAN, 0, "naked", &option_bare, NULL,
-                "create a bare repository",
-                PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
-        OPT_BOOLEAN(0, "mirror", &option_mirror,
-                    "create a mirror repository (implies bare)"),
-        OPT_BOOLEAN('l', "local", &option_local,
-                    "to clone from a local repository"),
-        OPT_BOOLEAN(0, "no-hardlinks", &option_no_hardlinks,
-                    "don't use local hardlinks, always copy"),
-        OPT_BOOLEAN('s', "shared", &option_shared,
-                    "setup as shared repository"),
-        OPT_BOOLEAN(0, "recursive", &option_recursive,
-                    "initialize submodules in the clone"),
-        OPT_BOOLEAN(0, "recurse-submodules", &option_recursive,
-                    "initialize submodules in the clone"),
-        OPT_STRING(0, "template", &option_template, "template-directory",
-                   "directory from which templates will be used"),
-        OPT_CALLBACK(0 , "reference", &option_reference, "repo",
-                     "reference repository", &opt_parse_reference),
-        OPT_STRING('o', "origin", &option_origin, "name",
-                   "use <name> instead of 'origin' to track upstream"),
-        OPT_STRING('b', "branch", &option_branch, "branch",
-                   "checkout <branch> instead of the remote's HEAD"),
-        OPT_STRING('u', "upload-pack", &option_upload_pack, "path",
-                   "path to git-upload-pack on the remote"),
-        OPT_STRING(0, "depth", &option_depth, "depth",
-                    "create a shallow clone of that depth"),
-        OPT_STRING(0, "separate-git-dir", &real_git_dir, "gitdir",
-                   "separate git dir from working tree"),
-        OPT_STRING_LIST('c', "config", &option_config, "key=value",
-                        "set config inside the new repository"),
+                 N_("force progress reporting")),
+        OPT_BOOL('n', "no-checkout", &option_no_checkout,
+                 N_("don't create a checkout")),
+        OPT_BOOL(0, "bare", &option_bare, N_("create a bare repository")),
+        OPT_HIDDEN_BOOL(0, "naked", &option_bare,
+                        N_("create a bare repository")),
+        OPT_BOOL(0, "mirror", &option_mirror,
+                 N_("create a mirror repository (implies bare)")),
+        OPT_BOOL('l', "local", &option_local,
+                N_("to clone from a local repository")),
+        OPT_BOOL(0, "no-hardlinks", &option_no_hardlinks,
+                    N_("don't use local hardlinks, always copy")),
+        OPT_BOOL('s', "shared", &option_shared,
+                    N_("setup as shared repository")),
+        OPT_BOOL(0, "recursive", &option_recursive,
+                    N_("initialize submodules in the clone")),
+        OPT_BOOL(0, "recurse-submodules", &option_recursive,
+                    N_("initialize submodules in the clone")),
+        OPT_STRING(0, "template", &option_template, N_("template-directory"),
+                   N_("directory from which templates will be used")),
+        OPT_CALLBACK(0 , "reference", &option_reference, N_("repo"),
+                     N_("reference repository"), &opt_parse_reference),
+        OPT_STRING('o', "origin", &option_origin, N_("name"),
+                   N_("use <name> instead of 'origin' to track upstream")),
+        OPT_STRING('b', "branch", &option_branch, N_("branch"),
+                   N_("checkout <branch> instead of the remote's HEAD")),
+        OPT_STRING('u', "upload-pack", &option_upload_pack, N_("path"),
+                   N_("path to git-upload-pack on the remote")),
+        OPT_STRING(0, "depth", &option_depth, N_("depth"),
+                    N_("create a shallow clone of that depth")),
+        OPT_BOOL(0, "single-branch", &option_single_branch,
+                    N_("clone only one branch, HEAD or --branch")),
+        OPT_STRING(0, "separate-git-dir", &real_git_dir, N_("gitdir"),
+                   N_("separate git dir from working tree")),
+        OPT_STRING_LIST('c', "config", &option_config, N_("key=value"),
+                        N_("set config inside the new repository")),
         OPT_END()
 };
@@ -230 +231 @@
 {
         char *ref_git;
+        const char *repo;
         struct strbuf alternate = STRBUF_INIT;
-        struct remote *remote;
-        struct transport *transport;
-        const struct ref *extra;
-
-        /* Beware: real_path() and mkpath() return static buffer */
+
+        /* Beware: read_gitfile(), real_path() and mkpath() return static buffer */
         ref_git = xstrdup(real_path(item->string));
-        if (is_directory(mkpath("%s/.git/objects", ref_git))) {
-                char *ref_git_git = xstrdup(mkpath("%s/.git", ref_git));
+
+        repo = read_gitfile(ref_git);
+        if (!repo)
+                repo = read_gitfile(mkpath("%s/.git", ref_git));
+        if (repo) {
+                free(ref_git);
+                ref_git = xstrdup(repo);
+        }
+
+        if (!repo && is_directory(mkpath("%s/.git/objects", ref_git))) {
+                char *ref_git_git = mkpathdup("%s/.git", ref_git);
                 free(ref_git);
                 ref_git = ref_git_git;
         } else if (!is_directory(mkpath("%s/objects", ref_git)))
-                die(_("reference repository '%s' is not a local directory."),
+                die(_("reference repository '%s' is not a local repository."),
                     item->string);
+
+        if (!access(mkpath("%s/shallow", ref_git), F_OK))
+                die(_("reference repository '%s' is shallow"), item->string);
+
+        if (!access(mkpath("%s/info/grafts", ref_git), F_OK))
+                die(_("reference repository '%s' is grafted"), item->string);
 
         strbuf_addf(&alternate, "%s/objects", ref_git);
         add_to_alternates_file(alternate.buf);
         strbuf_release(&alternate);
-
-        remote = remote_get(ref_git);
-        transport = transport_get(remote, ref_git);
-        for (extra = transport_get_remote_refs(transport); extra;
-             extra = extra->next)
-                add_extra_ref(extra->name, extra->old_sha1, 0);
-
-        transport_disconnect(transport);
         free(ref_git);
         return 0;
@@ -352 +358 @@
                         if (!link(src->buf, dest->buf))
                                 continue;
-                        if (option_local)
+                        if (option_local > 0)
                                 die_errno(_("failed to create link '%s'"), dest->buf);
                         option_no_hardlinks = 1;
@@ -362 +368 @@
 }
 
-static const struct ref *clone_local(const char *src_repo,
-                                     const char *dest_repo)
-{
-        const struct ref *ret;
-        struct remote *remote;
-        struct transport *transport;
-
+static void clone_local(const char *src_repo, const char *dest_repo)
+{
         if (option_shared) {
                 struct strbuf alt = STRBUF_INIT;
@@ -384 +385 @@
         }
 
-        remote = remote_get(src_repo);
-        transport = transport_get(remote, src_repo);
-        ret = transport_get_remote_refs(transport);
-        transport_disconnect(transport);
         if (0 <= option_verbosity)
-                printf(_("done.\n"));
-        return ret;
+                fprintf(stderr, _("done.\n"));
 }
 
@@ -396 +392 @@
 static const char *junk_git_dir;
 static pid_t junk_pid;
+static enum {
+        JUNK_LEAVE_NONE,
+        JUNK_LEAVE_REPO,
+        JUNK_LEAVE_ALL
+} junk_mode = JUNK_LEAVE_NONE;
+
+static const char junk_leave_repo_msg[] =
+N_("Clone succeeded, but checkout failed.\n"
+   "You can inspect what was checked out with 'git status'\n"
+   "and retry the checkout with 'git checkout -f HEAD'\n");
 
 static void remove_junk(void)
 {
         struct strbuf sb = STRBUF_INIT;
+
+        switch (junk_mode) {
+        case JUNK_LEAVE_REPO:
+                warning("%s", _(junk_leave_repo_msg));
+                /* fall-through */
+        case JUNK_LEAVE_ALL:
+                return;
+        default:
+                /* proceed to removal */
+                break;
+        }
+
         if (getpid() != junk_pid)
                 return;
@@ -421 +439 @@
 }
 
+static struct ref *find_remote_branch(const struct ref *refs, const char *branch)
+{
+        struct ref *ref;
+        struct strbuf head = STRBUF_INIT;
+        strbuf_addstr(&head, "refs/heads/");
+        strbuf_addstr(&head, branch);
+        ref = find_ref_by_name(refs, head.buf);
+        strbuf_release(&head);
+
+        if (ref)
+                return ref;
+
+        strbuf_addstr(&head, "refs/tags/");
+        strbuf_addstr(&head, branch);
+        ref = find_ref_by_name(refs, head.buf);
+        strbuf_release(&head);
+
+        return ref;
+}
+
 static struct ref *wanted_peer_refs(const struct ref *refs,
                 struct refspec *refspec)
@@ -428 +466 @@
         struct ref **tail = head ? &head->next : &local_refs;
 
-        get_fetch_map(refs, refspec, &tail, 0);
-        if (!option_mirror)
+        if (option_single_branch) {
+                struct ref *remote_head = NULL;
+
+                if (!option_branch)
+                        remote_head = guess_remote_head(head, refs, 0);
+                else {
+                        local_refs = NULL;
+                        tail = &local_refs;
+                        remote_head = copy_ref(find_remote_branch(refs, option_branch));
+                }
+
+                if (!remote_head && option_branch)
+                        warning(_("Could not find remote branch %s to clone."),
+                                option_branch);
+                else {
+                        get_fetch_map(remote_head, refspec, &tail, 0);
+
+                        /* if --branch=tag, pull the requested tag explicitly */
+                        get_fetch_map(remote_head, tag_refspec, &tail, 0);
+                }
+        } else
+                get_fetch_map(refs, refspec, &tail, 0);
+
+        if (!option_mirror && !option_single_branch)
                 get_fetch_map(refs, tag_refspec, &tail, 0);
 
@@ -438 +498 @@
 {
         const struct ref *r;
+
+        lock_packed_refs(LOCK_DIE_ON_ERROR);
 
         for (r = local_refs; r; r = r->next) {
                 if (!r->peer_ref)
                         continue;
-                add_extra_ref(r->peer_ref->name, r->old_sha1, 0);
-        }
-
-        pack_refs(PACK_REFS_ALL);
-        clear_extra_refs();
+                add_packed_ref(r->peer_ref->name, r->old_sha1);
+        }
+
+        if (commit_packed_refs())
+                die_errno("unable to overwrite old ref-pack file");
+}
+
+static void write_followtags(const struct ref *refs, const char *msg)
+{
+        const struct ref *ref;
+        for (ref = refs; ref; ref = ref->next) {
+                if (!starts_with(ref->name, "refs/tags/"))
+                        continue;
+                if (ends_with(ref->name, "^{}"))
+                        continue;
+                if (!has_sha1_file(ref->old_sha1))
+                        continue;
+                update_ref(msg, ref->name, ref->old_sha1,
+                           NULL, 0, DIE_ON_ERR);
+        }
+}
+
+static int iterate_ref_map(void *cb_data, unsigned char sha1[20])
+{
+        struct ref **rm = cb_data;
+        struct ref *ref = *rm;
+
+        /*
+         * Skip anything missing a peer_ref, which we are not
+         * actually going to write a ref for.
+         */
+        while (ref && !ref->peer_ref)
+                ref = ref->next;
+        /* Returning -1 notes "end of list" to the caller. */
+        if (!ref)
+                return -1;
+
+        hashcpy(sha1, ref->old_sha1);
+        *rm = ref->next;
+        return 0;
+}
+
+static void update_remote_refs(const struct ref *refs,
+                               const struct ref *mapped_refs,
+                               const struct ref *remote_head_points_at,
+                               const char *branch_top,
+                               const char *msg,
+                               struct transport *transport,
+                               int check_connectivity)
+{
+        const struct ref *rm = mapped_refs;
+
+        if (check_connectivity) {
+                if (transport->progress)
+                        fprintf(stderr, _("Checking connectivity... "));
+                if (check_everything_connected_with_transport(iterate_ref_map,
+                                                              0, &rm, transport))
+                        die(_("remote did not send all necessary objects"));
+                if (transport->progress)
+                        fprintf(stderr, _("done.\n"));
+        }
+
+        if (refs) {
+                write_remote_refs(mapped_refs);
+                if (option_single_branch)
+                        write_followtags(refs, msg);
+        }
+
+        if (remote_head_points_at && !option_bare) {
+                struct strbuf head_ref = STRBUF_INIT;
+                strbuf_addstr(&head_ref, branch_top);
+                strbuf_addstr(&head_ref, "HEAD");
+                create_symref(head_ref.buf,
+                              remote_head_points_at->peer_ref->name,
+                              msg);
+        }
+}
+
+static void update_head(const struct ref *our, const struct ref *remote,
+                        const char *msg)
+{
+        if (our && starts_with(our->name, "refs/heads/")) {
+                /* Local default branch link */
+                create_symref("HEAD", our->name, NULL);
+                if (!option_bare) {
+                        const char *head = skip_prefix(our->name, "refs/heads/");
+                        update_ref(msg, "HEAD", our->old_sha1, NULL, 0, DIE_ON_ERR);
+                        install_branch_config(0, head, option_origin, our->name);
+                }
+        } else if (our) {
+                struct commit *c = lookup_commit_reference(our->old_sha1);
+                /* --branch specifies a non-branch (i.e. tags), detach HEAD */
+                update_ref(msg, "HEAD", c->object.sha1,
+                           NULL, REF_NODEREF, DIE_ON_ERR);
+        } else if (remote) {
+                /*
+                 * We know remote HEAD points to a non-branch, or
+                 * HEAD points to a branch but we don't know which one.
+                 * Detach HEAD in all these cases.
+                 */
+                update_ref(msg, "HEAD", remote->old_sha1,
+                           NULL, REF_NODEREF, DIE_ON_ERR);
+        }
+}
+
+static int checkout(void)
+{
+        unsigned char sha1[20];
+        char *head;
+        struct lock_file *lock_file;
+        struct unpack_trees_options opts;
+        struct tree *tree;
+        struct tree_desc t;
+        int err = 0, fd;
+
+        if (option_no_checkout)
+                return 0;
+
+        head = resolve_refdup("HEAD", sha1, 1, NULL);
+        if (!head) {
+                warning(_("remote HEAD refers to nonexistent ref, "
+                          "unable to checkout.\n"));
+                return 0;
+        }
+        if (!strcmp(head, "HEAD")) {
+                if (advice_detached_head)
+                        detach_advice(sha1_to_hex(sha1));
+        } else {
+                if (!starts_with(head, "refs/heads/"))
+                        die(_("HEAD not found below refs/heads!"));
+        }
+        free(head);
+
+        /* We need to be in the new work tree for the checkout */
+        setup_work_tree();
+
+        lock_file = xcalloc(1, sizeof(struct lock_file));
+        fd = hold_locked_index(lock_file, 1);
+
+        memset(&opts, 0, sizeof opts);
+        opts.update = 1;
+        opts.merge = 1;
+        opts.fn = oneway_merge;
+        opts.verbose_update = (option_verbosity >= 0);
+        opts.src_index = &the_index;
+        opts.dst_index = &the_index;
+
+        tree = parse_tree_indirect(sha1);
+        parse_tree(tree);
+        init_tree_desc(&t, tree->buffer, tree->size);
+        if (unpack_trees(1, &t, &opts) < 0)
+                die(_("unable to checkout working tree"));
+
+        if (write_cache(fd, active_cache, active_nr) ||
+            commit_locked_index(lock_file))
+                die(_("unable to write new index file"));
+
+        err |= run_hook_le(NULL, "post-checkout", sha1_to_hex(null_sha1),
+                           sha1_to_hex(sha1), "1", NULL);
+
+        if (!err && option_recursive)
+                err = run_command_v_opt(argv_submodule, RUN_GIT_CMD);
+
+        return err;
 }
 
@@ -463 +684 @@
                         die("unable to write parameters to config file");
         }
+}
+
+static void write_refspec_config(const char* src_ref_prefix,
+                const struct ref* our_head_points_at,
+                const struct ref* remote_head_points_at, struct strbuf* branch_top)
+{
+        struct strbuf key = STRBUF_INIT;
+        struct strbuf value = STRBUF_INIT;
+
+        if (option_mirror || !option_bare) {
+                if (option_single_branch && !option_mirror) {
+                        if (option_branch) {
+                                if (strstr(our_head_points_at->name, "refs/tags/"))
+                                        strbuf_addf(&value, "+%s:%s", our_head_points_at->name,
+                                                our_head_points_at->name);
+                                else
+                                        strbuf_addf(&value, "+%s:%s%s", our_head_points_at->name,
+                                                branch_top->buf, option_branch);
+                        } else if (remote_head_points_at) {
+                                strbuf_addf(&value, "+%s:%s%s", remote_head_points_at->name,
+                                                branch_top->buf,
+                                                skip_prefix(remote_head_points_at->name, "refs/heads/"));
+                        }
+                        /*
+                         * otherwise, the next "git fetch" will
+                         * simply fetch from HEAD without updating
+                         * any remote-tracking branch, which is what
+                         * we want.
+                         */
+                } else {
+                        strbuf_addf(&value, "+%s*:%s*", src_ref_prefix, branch_top->buf);
+                }
+                /* Configure the remote */
+                if (value.len) {
+                        strbuf_addf(&key, "remote.%s.fetch", option_origin);
+                        git_config_set_multivar(key.buf, value.buf, "^$", 0);
+                        strbuf_reset(&key);
+
+                        if (option_mirror) {
+                                strbuf_addf(&key, "remote.%s.mirror", option_origin);
+                                git_config_set(key.buf, "true");
+                                strbuf_reset(&key);
+                        }
+                }
+        }
+
+        strbuf_release(&key);
+        strbuf_release(&value);
 }
 
@@ -476 +745 @@
         const struct ref *our_head_points_at;
         struct ref *mapped_refs;
+        const struct ref *ref;
         struct strbuf key = STRBUF_INIT, value = STRBUF_INIT;
         struct strbuf branch_top = STRBUF_INIT, reflog_msg = STRBUF_INIT;
         struct transport *transport = NULL;
-        char *src_ref_prefix = "refs/heads/";
-        int err = 0;
+        const char *src_ref_prefix = "refs/heads/";
+        struct remote *remote;
+        int err = 0, complete_refs_before_fetch = 1;
 
         struct refspec *refspec;
@@ -498 +769 @@
                 usage_msg_opt(_("You must specify a repository to clone."),
                         builtin_clone_usage, builtin_clone_options);
+
+        if (option_single_branch == -1)
+                option_single_branch = option_depth ? 1 : 0;
 
         if (option_mirror)
@@ -506 +780 @@
                         die(_("--bare and --origin %s options are incompatible."),
                             option_origin);
+                if (real_git_dir)
+                        die(_("--bare and --separate-git-dir are incompatible."));
                 option_no_checkout = 1;
         }
@@ -521 +797 @@
         else
                 repo = repo_name;
-        is_local = path && !is_bundle;
-        if (is_local && option_depth)
-                warning(_("--depth is ignored in local clones; use file:// instead."));
+        is_local = option_local != 0 && path && !is_bundle;
+        if (is_local) {
+                if (option_depth)
+                        warning(_("--depth is ignored in local clones; use file:// instead."));
+                if (!access(mkpath("%s/shallow", path), F_OK)) {
+                        if (option_local > 0)
+                                warning(_("source repository is shallow, ignoring --local"));
+                        is_local = 0;
+                }
+        }
+        if (option_local > 0 && !is_local)
+                warning(_("--local is ignored"));
+
+        /* no need to be strict, transport_set_option() will validate it again */
+        if (option_depth && atoi(option_depth) < 1)
+                die(_("depth %s is not a positive number"), option_depth);
 
         if (argc == 2)
@@ -550 +839 @@
         else {
                 work_tree = dir;
-                git_dir = xstrdup(mkpath("%s/.git", dir));
+                git_dir = mkpathdup("%s/.git", dir);
         }
 
@@ -558 +847 @@
                         die_errno(_("could not create leading directories of '%s'"),
                                   work_tree);
-                if (!dest_exists && mkdir(work_tree, 0755))
+                if (!dest_exists && mkdir(work_tree, 0777))
                         die_errno(_("could not create work tree dir '%s'."),
                                   work_tree);
@@ -567 +856 @@
         sigchain_push_common(remove_junk_on_signal);
 
-        setenv(CONFIG_ENVIRONMENT, mkpath("%s/config", git_dir), 1);
-
         if (safe_create_leading_directories_const(git_dir) < 0)
                 die(_("could not create leading directories of '%s'"), git_dir);
 
         set_git_dir_init(git_dir, real_git_dir, 0);
-        if (real_git_dir)
+        if (real_git_dir) {
                 git_dir = real_git_dir;
+                junk_git_dir = real_git_dir;
+        }
 
         if (0 <= option_verbosity) {
                 if (option_bare)
-                        printf(_("Cloning into bare repository '%s'...\n"), dir);
+                        fprintf(stderr, _("Cloning into bare repository '%s'...\n"), dir);
                 else
-                        printf(_("Cloning into '%s'...\n"), dir);
+                        fprintf(stderr, _("Cloning into '%s'...\n"), dir);
         }
         init_db(option_template, INIT_DB_QUIET);
         write_config(&option_config);
-
-        /*
-         * At this point, the config exists, so we do not need the
-         * environment variable.  We actually need to unset it, too, to
-         * re-enable parsing of the global configs.
-         */
-        unsetenv(CONFIG_ENVIRONMENT);
 
         git_config(git_default_config, NULL);
@@ -605 +887 @@
 
         strbuf_addf(&value, "+%s*:%s*", src_ref_prefix, branch_top.buf);
-
-        if (option_mirror || !option_bare) {
-                /* Configure the remote */
-                strbuf_addf(&key, "remote.%s.fetch", option_origin);
-                git_config_set_multivar(key.buf, value.buf, "^$", 0);
-                strbuf_reset(&key);
-
-                if (option_mirror) {
-                        strbuf_addf(&key, "remote.%s.mirror", option_origin);
-                        git_config_set(key.buf, "true");
-                        strbuf_reset(&key);
-                }
-        }
-
         strbuf_addf(&key, "remote.%s.url", option_origin);
         git_config_set(key.buf, repo);
@@ -631 +899 @@
         strbuf_reset(&value);
 
-        if (is_local) {
-                refs = clone_local(path, git_dir);
+        remote = remote_get(option_origin);
+        transport = transport_get(remote, remote->url[0]);
+        transport->cloning = 1;
+
+        if (!transport->get_refs_list || (!is_local && !transport->fetch))
+                die(_("Don't know how to clone %s"), transport->url);
+
+        transport_set_option(transport, TRANS_OPT_KEEP, "yes");
+
+        if (option_depth)
+                transport_set_option(transport, TRANS_OPT_DEPTH,
+                                     option_depth);
+        if (option_single_branch)
+                transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
+
+        transport_set_verbosity(transport, option_verbosity, option_progress);
+
+        if (option_upload_pack)
+                transport_set_option(transport, TRANS_OPT_UPLOADPACK,
+                                     option_upload_pack);
+
+        if (transport->smart_options && !option_depth)
+                transport->smart_options->check_self_contained_and_connected = 1;
+
+        refs = transport_get_remote_refs(transport);
+
+        if (refs) {
                 mapped_refs = wanted_peer_refs(refs, refspec);
-        } else {
-                struct remote *remote = remote_get(option_origin);
-                transport = transport_get(remote, remote->url[0]);
-
-                if (!transport->get_refs_list || !transport->fetch)
-                        die(_("Don't know how to clone %s"), transport->url);
-
-                transport_set_option(transport, TRANS_OPT_KEEP, "yes");
-
-                if (option_depth)
-                        transport_set_option(transport, TRANS_OPT_DEPTH,
-                                             option_depth);
-
-                transport_set_verbosity(transport, option_verbosity, option_progress);
-
-                if (option_upload_pack)
-                        transport_set_option(transport, TRANS_OPT_UPLOADPACK,
-                                             option_upload_pack);
-
-                refs = transport_get_remote_refs(transport);
-                if (refs) {
-                        mapped_refs = wanted_peer_refs(refs, refspec);
+                /*
+                 * transport_get_remote_refs() may return refs with null sha-1
+                 * in mapped_refs (see struct transport->get_refs_list
+                 * comment). In that case we need fetch it early because
+                 * remote_head code below relies on it.
+                 *
+                 * for normal clones, transport_get_remote_refs() should
+                 * return reliable ref set, we can delay cloning until after
+                 * remote HEAD check.
+                 */
+                for (ref = refs; ref; ref = ref->next)
+                        if (is_null_sha1(ref->old_sha1)) {
+                                complete_refs_before_fetch = 0;
+                                break;
+                        }
+
+                if (!is_local && !complete_refs_before_fetch)
                         transport_fetch_refs(transport, mapped_refs);
-                }
-        }
-
-        if (refs) {
-                clear_extra_refs();
-
-                write_remote_refs(mapped_refs);
 
                 remote_head = find_ref_by_name(refs, "HEAD");
@@ -670 +951 @@
 
                 if (option_branch) {
-                        struct strbuf head = STRBUF_INIT;
-                        strbuf_addstr(&head, src_ref_prefix);
-                        strbuf_addstr(&head, option_branch);
                         our_head_points_at =
-                                find_ref_by_name(mapped_refs, head.buf);
-                        strbuf_release(&head);
-
-                        if (!our_head_points_at) {
-                                warning(_("Remote branch %s not found in "
-                                        "upstream %s, using HEAD instead"),
-                                        option_branch, option_origin);
-                                our_head_points_at = remote_head_points_at;
-                        }
+                                find_remote_branch(mapped_refs, option_branch);
+
+                        if (!our_head_points_at)
+                                die(_("Remote branch %s not found in upstream %s"),
+                                    option_branch, option_origin);
                 }
                 else
@@ -688 +962 @@
         }
         else {
+                if (option_branch)
+                        die(_("Remote branch %s not found in upstream %s"),
+                                        option_branch, option_origin);
+
                 warning(_("You appear to have cloned an empty repository."));
+                mapped_refs = NULL;
                 our_head_points_at = NULL;
                 remote_head_points_at = NULL;
@@ -698 +977 @@
         }
 
-        if (remote_head_points_at && !option_bare) {
-                struct strbuf head_ref = STRBUF_INIT;
-                strbuf_addstr(&head_ref, branch_top.buf);
-                strbuf_addstr(&head_ref, "HEAD");
-                create_symref(head_ref.buf,
-                              remote_head_points_at->peer_ref->name,
-                              reflog_msg.buf);
-        }
-
-        if (our_head_points_at) {
-                /* Local default branch link */
-                create_symref("HEAD", our_head_points_at->name, NULL);
-                if (!option_bare) {
-                        const char *head = skip_prefix(our_head_points_at->name,
-                                                       "refs/heads/");
-                        update_ref(reflog_msg.buf, "HEAD",
-                                   our_head_points_at->old_sha1,
-                                   NULL, 0, DIE_ON_ERR);
-                        install_branch_config(0, head, option_origin,
-                                              our_head_points_at->name);
-                }
-        } else if (remote_head) {
-                /* Source had detached HEAD pointing somewhere. */
-                if (!option_bare) {
-                        update_ref(reflog_msg.buf, "HEAD",
-                                   remote_head->old_sha1,
-                                   NULL, REF_NODEREF, DIE_ON_ERR);
-                        our_head_points_at = remote_head;
-                }
-        } else {
-                /* Nothing to checkout out */
-                if (!option_no_checkout)
-                        warning(_("remote HEAD refers to nonexistent ref, "
-                                "unable to checkout.\n"));
-                option_no_checkout = 1;
-        }
-
-        if (transport) {
-                transport_unlock_pack(transport);
-                transport_disconnect(transport);
-        }
-
-        if (!option_no_checkout) {
-                struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
-                struct unpack_trees_options opts;
-                struct tree *tree;
-                struct tree_desc t;
-                int fd;
-
-                /* We need to be in the new work tree for the checkout */
-                setup_work_tree();
-
-                fd = hold_locked_index(lock_file, 1);
-
-                memset(&opts, 0, sizeof opts);
-                opts.update = 1;
-                opts.merge = 1;
-                opts.fn = oneway_merge;
-                opts.verbose_update = (option_verbosity > 0);
-                opts.src_index = &the_index;
-                opts.dst_index = &the_index;
-
-                tree = parse_tree_indirect(our_head_points_at->old_sha1);
-                parse_tree(tree);
-                init_tree_desc(&t, tree->buffer, tree->size);
-                unpack_trees(1, &t, &opts);
-
-                if (write_cache(fd, active_cache, active_nr) ||
-                    commit_locked_index(lock_file))
-                        die(_("unable to write new index file"));
-
-                err |= run_hook(NULL, "post-checkout", sha1_to_hex(null_sha1),
-                                sha1_to_hex(our_head_points_at->old_sha1), "1",
-                                NULL);
-
-                if (!err && option_recursive)
-                        err = run_command_v_opt(argv_submodule, RUN_GIT_CMD);
-        }
+        write_refspec_config(src_ref_prefix, our_head_points_at,
+                        remote_head_points_at, &branch_top);
+
+        if (is_local)
+                clone_local(path, git_dir);
+        else if (refs && complete_refs_before_fetch)
+                transport_fetch_refs(transport, mapped_refs);
+
+        update_remote_refs(refs, mapped_refs, remote_head_points_at,
+                           branch_top.buf, reflog_msg.buf, transport, !is_local);
+
+        update_head(our_head_points_at, remote_head, reflog_msg.buf);
+
+        transport_unlock_pack(transport);
+        transport_disconnect(transport);
+
+        junk_mode = JUNK_LEAVE_REPO;
+        err = checkout();
 
         strbuf_release(&reflog_msg);
@@ -781 +1000 @@
         strbuf_release(&key);
         strbuf_release(&value);
-        junk_pid = 0;
+        junk_mode = JUNK_LEAVE_ALL;
         return err;
 }