[PATCH v6 0/3] Cloning with remote unborn HEAD

I don't think we have consensus on whether the "unborn" config should be
advertise/allow/ignore or allow/ignore, so I have left that the same as
in version 5.

But as Junio suggested, I have isolated the reading of config into a
function and some global variables (so that one part can "leave a note"
to the other), so we could have advertise/allow/ignore (if we want)
without making the rest of the code much more complicated.

Other changes:
 - Updated the if/else cascade that parses the input to ls-refs to
   follow Junio's suggestion - "else if (!strcmp("unborn", arg)) {".
 - Moved create_symref() to cover the exact case it's needed.
 - Squashed Ramsay Jones's and Peff's patches.

Jonathan Tan (3):
  ls-refs: report unborn targets of symrefs
  connect, transport: encapsulate arg in struct
  clone: respect remote unborn HEAD

 Documentation/config.txt                |  2 +
 Documentation/config/init.txt           |  2 +-
 Documentation/config/lsrefs.txt         |  3 ++
 Documentation/technical/protocol-v2.txt | 10 ++++-
 builtin/clone.c                         | 34 ++++++++++----
 builtin/fetch-pack.c                    |  3 +-
 builtin/fetch.c                         | 18 +++++---
 builtin/ls-remote.c                     |  9 ++--
 connect.c                               | 32 ++++++++++++--
 ls-refs.c                               | 59 +++++++++++++++++++++++--
 ls-refs.h                               |  1 +
 remote.h                                |  4 +-
 serve.c                                 |  2 +-
 t/t5606-clone-options.sh                |  8 ++--
 t/t5701-git-serve.sh                    |  2 +-
 t/t5702-protocol-v2.sh                  | 25 +++++++++++
 transport-helper.c                      |  5 ++-
 transport-internal.h                    | 10 +----
 transport.c                             | 23 +++++-----
 transport.h                             | 29 +++++++++---
 20 files changed, 218 insertions(+), 63 deletions(-)
 create mode 100644 Documentation/config/lsrefs.txt

Range-diff against v5:
1:  cb033f9abc ! 1:  411bbafe25 ls-refs: report unborn targets of symrefs
    @@ Documentation/technical/protocol-v2.txt: ls-refs takes in the following argument
          peeled = "peeled:" obj-id
     
      ## ls-refs.c ##
    +@@
    + #include "pkt-line.h"
    + #include "config.h"
    + 
    ++static int config_read;
    ++static int allow_unborn;
    ++
    ++static void ensure_config_read(void)
    ++{
    ++	if (config_read)
    ++		return;
    ++
    ++	if (repo_config_get_bool(the_repository, "lsrefs.allowunborn",
    ++				 &allow_unborn))
    ++		/*
    ++		 * If there is no such config, set it to 1 to allow it by
    ++		 * default.
    ++		 */
    ++		allow_unborn = 1;
    ++	config_read = 1;
    ++}
    ++
    + /*
    +  * Check if one of the prefixes is a prefix of the ref.
    +  * If no prefixes were provided, all refs match.
     @@ ls-refs.c: struct ls_refs_data {
      	unsigned peel;
      	unsigned symrefs;
      	struct strvec prefixes;
    -+	unsigned allow_unborn : 1;
     +	unsigned unborn : 1;
      };
      
    @@ ls-refs.c: static int send_ref(const char *refname, const struct object_id *oid,
      	if (data->symrefs && flag & REF_ISSYMREF) {
      		struct object_id unused;
      		const char *symref_target = resolve_ref_unsafe(refname, 0,
    +@@ ls-refs.c: static int send_ref(const char *refname, const struct object_id *oid,
    + 			    strip_namespace(symref_target));
    + 	}
    + 
    +-	if (data->peel) {
    ++	if (data->peel && oid) {
    + 		struct object_id peeled;
    + 		if (!peel_ref(refname, &peeled))
    + 			strbuf_addf(&refline, " peeled:%s", oid_to_hex(&peeled));
     @@ ls-refs.c: static int send_ref(const char *refname, const struct object_id *oid,
      	return 0;
      }
      
    --static int ls_refs_config(const char *var, const char *value, void *data)
     +static void send_possibly_unborn_head(struct ls_refs_data *data)
    - {
    ++{
     +	struct strbuf namespaced = STRBUF_INIT;
     +	struct object_id oid;
     +	int flag;
    @@ ls-refs.c: static int send_ref(const char *refname, const struct object_id *oid,
     +	strbuf_release(&namespaced);
     +}
     +
    -+static int ls_refs_config(const char *var, const char *value, void *cb_data)
    -+{
    -+	struct ls_refs_data *data = cb_data;
    -+
    -+	if (!strcmp("lsrefs.allowunborn", var))
    -+		data->allow_unborn = git_config_bool(var, value);
    -+
    + static int ls_refs_config(const char *var, const char *value, void *data)
    + {
      	/*
    - 	 * We only serve fetches over v2 for now, so respect only "uploadpack"
    - 	 * config. This may need to eventually be expanded to "receive", but we
     @@ ls-refs.c: int ls_refs(struct repository *r, struct strvec *keys,
      
      	memset(&data, 0, sizeof(data));
      
    --	git_config(ls_refs_config, NULL);
    -+	data.allow_unborn = 1;
    -+	git_config(ls_refs_config, &data);
    ++	ensure_config_read();
    + 	git_config(ls_refs_config, NULL);
      
      	while (packet_reader_read(request) == PACKET_READ_NORMAL) {
    - 		const char *arg = request->line;
     @@ ls-refs.c: int ls_refs(struct repository *r, struct strvec *keys,
      			data.symrefs = 1;
      		else if (skip_prefix(arg, "ref-prefix ", &out))
      			strvec_push(&data.prefixes, out);
    -+		else if (data.allow_unborn && !strcmp("unborn", arg))
    -+			data.unborn = 1;
    ++		else if (!strcmp("unborn", arg))
    ++			data.unborn = allow_unborn;
      	}
      
      	if (request->status != PACKET_READ_FLUSH)
    @@ ls-refs.c: int ls_refs(struct repository *r, struct strvec *keys,
     +int ls_refs_advertise(struct repository *r, struct strbuf *value)
     +{
     +	if (value) {
    -+		int allow_unborn_value;
    -+
    -+		if (repo_config_get_bool(the_repository,
    -+					 "lsrefs.allowunborn",
    -+					 &allow_unborn_value) ||
    -+		    allow_unborn_value)
    ++		ensure_config_read();
    ++		if (allow_unborn)
     +			strbuf_addstr(value, "unborn");
     +	}
     +
2:  0c7ab71872 ! 2:  fad1ebe6b6 connect, transport: encapsulate arg in struct
    @@ transport-helper.c: static int has_attribute(const char *attrs, const char *attr
      	return get_refs_list_using_list(transport, for_push);
     
      ## transport-internal.h ##
    +@@
    + struct ref;
    + struct transport;
    + struct strvec;
    ++struct transport_ls_refs_options;
    + 
    + struct transport_vtable {
    + 	/**
     @@ transport-internal.h: struct transport_vtable {
      	 * the transport to try to share connections, for_push is a
      	 * hint as to whether the ultimate operation is a push or a fetch.
3:  8015415c79 ! 3:  45a48ccc0d clone: respect remote unborn HEAD
    @@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
     +					"refs/heads/", &branch)) {
     +				ref = transport_ls_refs_options.unborn_head_target;
     +				transport_ls_refs_options.unborn_head_target = NULL;
    ++				create_symref("HEAD", ref, reflog_msg.buf);
     +			} else {
     +				branch = git_default_branch_name();
     +				ref = xstrfmt("refs/heads/%s", branch);
     +			}
      
      			install_branch_config(0, branch, remote_name, ref);
    -+			create_symref("HEAD", ref, "");
      			free(ref);
    - 		}
    - 	}
     @@ builtin/clone.c: int cmd_clone(int argc, const char **argv, const char *prefix)
      	junk_mode = JUNK_LEAVE_ALL;
      
4:  1c06db6494 < -:  ---------- ls-refs: don't peel NULL oid
5:  30d83a9dfa < -:  ---------- transport-internal.h: fix a 'hdr-check' warning
-- 
2.30.0.365.g02bc693789-goog