From patchwork Tue Mar 29 21:49:38 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "brian m. carlson" X-Patchwork-Id: 12795278 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A4DBBC433FE for ; Tue, 29 Mar 2022 21:49:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235096AbiC2Vvj (ORCPT ); Tue, 29 Mar 2022 17:51:39 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34208 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235006AbiC2Vvh (ORCPT ); Tue, 29 Mar 2022 17:51:37 -0400 Received: from ring.crustytoothpaste.net (ring.crustytoothpaste.net [IPv6:2600:3c04::f03c:92ff:fe9e:c6d8]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0FC3947390 for ; Tue, 29 Mar 2022 14:49:52 -0700 (PDT) Received: from camp.crustytoothpaste.net (ipagstaticip-2d4b363b-56b8-9979-23b8-fd468af1db4c.sdsl.bell.ca [142.112.6.242]) (using TLSv1.2 with cipher ECDHE-RSA-CHACHA20-POLY1305 (256/256 bits)) (No client certificate requested) by ring.crustytoothpaste.net (Postfix) with ESMTPSA id D332E5A3DB; Tue, 29 Mar 2022 21:49:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=crustytoothpaste.net; s=default; t=1648590591; bh=e1heZ5iu+vHK6AExECRdXfQJdgRLSg4U/ygA52vOhCU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From:Reply-To: Subject:Date:To:CC:Resent-Date:Resent-From:Resent-To:Resent-Cc: In-Reply-To:References:Content-Type:Content-Disposition; b=p/UP7wgFZib4XWCl+DAOT7efz19PlVMt7XTqQb7YTMMrgemIHftefeWV/e5OG/xk2 u3HBfARkWRk77+oH8WYx4Q/aFgI84P1lzdXKm5HFa44ZB59P4Q1tZOvcylkSpLl2z5 AmgZjs5x6ei7dLEY3P3vHHgKg1ITCDrimnzUZC66eobhAiPys6xgqEvaZM06y/dxpX Jt3AH0+XtteCccFM4sdaD8rWEpD3smoEvYtHpBhiiVjoCz3P+x3nI8wzn4osVOKCr8 34PdNIp9pK4Wca3J4m6ZakWxbrPGM+G6goakP0Vz0NCmkiirTPxe71wfeTeWPh58oL nYyUGBJEefGbXgxxQxtfHP5BU3aV8hJlrtaYMkxIFGIF34Xw6oyzz5nfc/o2FWYGqD sT4PEUGmW+5lo+w0aBb6jlOw4X28FFrdsXUTC+HrHUFtGjMKFAino0PCrSZjUW6YXm BhllneKDfMgy8te8SYAuX6081ldOQaJ1MLQr1XcLaU3Dm0c1wB1 From: "brian m. carlson" To: Cc: Junio C Hamano , Phillip Wood , =?utf-8?b?w4Z2YXIgQXJuZmrDtnI=?= =?utf-8?b?w7AgQmphcm1hc29u?= Subject: [PATCH v2 1/4] object-name: make get_oid quietly return an error Date: Tue, 29 Mar 2022 21:49:38 +0000 Message-Id: <20220329214941.2018609-2-sandals@crustytoothpaste.net> X-Mailer: git-send-email 2.35.1.473.g83b2b277ed In-Reply-To: <20220329214941.2018609-1-sandals@crustytoothpaste.net> References: <20220310173236.4165310-1-sandals@crustytoothpaste.net> <20220329214941.2018609-1-sandals@crustytoothpaste.net> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org A reasonable person looking at the signature and usage of get_oid and friends might conclude that in the event of an error, it always returns -1. However, this is not the case. Instead, get_oid_basic dies if we go too far back into the history of a reflog (or, when quiet, simply exits). This is not especially useful, since in many cases, we might want to handle this error differently. Let's add a flag here to make it just return -1 like elsewhere in these code paths. Note that we cannot make this behavior the default, since we have many other codepaths that rely on the existing behavior, including in tests. Signed-off-by: brian m. carlson --- cache.h | 1 + object-name.c | 6 +++++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/cache.h b/cache.h index 825ec17198..657e3ff17f 100644 --- a/cache.h +++ b/cache.h @@ -1376,6 +1376,7 @@ struct object_context { #define GET_OID_RECORD_PATH 0200 #define GET_OID_ONLY_TO_DIE 04000 #define GET_OID_REQUIRE_PATH 010000 +#define GET_OID_GENTLY 020000 #define GET_OID_DISAMBIGUATORS \ (GET_OID_COMMIT | GET_OID_COMMITTISH | \ diff --git a/object-name.c b/object-name.c index 92862eeb1a..46dbfe36a6 100644 --- a/object-name.c +++ b/object-name.c @@ -911,13 +911,17 @@ static int get_oid_basic(struct repository *r, const char *str, int len, len, str, show_date(co_time, co_tz, DATE_MODE(RFC2822))); } - } else { + } else if (!(flags & GET_OID_GENTLY)) { if (flags & GET_OID_QUIETLY) { exit(128); } die(_("log for '%.*s' only has %d entries"), len, str, co_cnt); } + if (flags & GET_OID_GENTLY) { + free(real_ref); + return -1; + } } } From patchwork Tue Mar 29 21:49:39 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "brian m. carlson" X-Patchwork-Id: 12795277 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B1BA0C433F5 for ; Tue, 29 Mar 2022 21:49:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235088AbiC2Vvi (ORCPT ); Tue, 29 Mar 2022 17:51:38 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34206 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234905AbiC2Vvh (ORCPT ); Tue, 29 Mar 2022 17:51:37 -0400 Received: from ring.crustytoothpaste.net (ring.crustytoothpaste.net [IPv6:2600:3c04::f03c:92ff:fe9e:c6d8]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0FA934738F for ; Tue, 29 Mar 2022 14:49:52 -0700 (PDT) Received: from camp.crustytoothpaste.net (ipagstaticip-2d4b363b-56b8-9979-23b8-fd468af1db4c.sdsl.bell.ca [142.112.6.242]) (using TLSv1.2 with cipher ECDHE-RSA-CHACHA20-POLY1305 (256/256 bits)) (No client certificate requested) by ring.crustytoothpaste.net (Postfix) with ESMTPSA id E2D0C5A3DC; Tue, 29 Mar 2022 21:49:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=crustytoothpaste.net; s=default; t=1648590591; bh=CPomXpIHqKBhTF6pLDNs9s22y3itA/jk84LgRY+Fkc0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From:Reply-To: Subject:Date:To:CC:Resent-Date:Resent-From:Resent-To:Resent-Cc: In-Reply-To:References:Content-Type:Content-Disposition; b=c0swXtFgqNWrZJjErmOFrOMwP8GL+G3f/4hmqDlAXlXhLNSDFPs0eoFWXH1V+0iiU s98RsBcRIluAisZHFmYW4tEB7SQq6cGkANGbOLL+BeMGsAn9XYP+WFmo2SBqskAItz sMyg2YighktY/d72ARgm+ykqvO4CTOfkoEXCnkc8qJSlwD2Aijd5q1X3L+63Hn5yLA FPGl2E62CHqhuJt44BoaY0nbxryaVWHHrt2VJmTVC+/1Trf1xuZmYLvbZ+9ts7r6md tDiipwDNXJCs3/AhF5SrcFSArHRr0jj0qcy0XoriEc93SG4+tmyg/9prco4vf+/CQJ FIWeOFe9nnnkY5Q0+0vgtR9kR9cr6Cd++q/vsq1U8oHQyCWe8bt/1+YmA+L/ihcc8t 2dr7H5OEM7nez0/Bt/rPdP+0slKH25N6jn72k64zw3IYjfPlpzl+A7rxTUlC9BTPsZ CbRWOh2v2BM3R5RtzBprVRs6bxHi1ITfa8FiSWB2oK8yf5ZqQP0 From: "brian m. carlson" To: Cc: Junio C Hamano , Phillip Wood , =?utf-8?b?w4Z2YXIgQXJuZmrDtnI=?= =?utf-8?b?w7AgQmphcm1hc29u?= Subject: [PATCH v2 2/4] builtin/stash: factor out revision parsing into a function Date: Tue, 29 Mar 2022 21:49:39 +0000 Message-Id: <20220329214941.2018609-3-sandals@crustytoothpaste.net> X-Mailer: git-send-email 2.35.1.473.g83b2b277ed In-Reply-To: <20220329214941.2018609-1-sandals@crustytoothpaste.net> References: <20220310173236.4165310-1-sandals@crustytoothpaste.net> <20220329214941.2018609-1-sandals@crustytoothpaste.net> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org We allow several special forms of stash names in this code. In the future, we'll want to allow these same forms without parsing a stash commit, so let's refactor this code out into a function for reuse. Signed-off-by: brian m. carlson --- builtin/stash.c | 34 +++++++++++++++++++++------------- 1 file changed, 21 insertions(+), 13 deletions(-) diff --git a/builtin/stash.c b/builtin/stash.c index 5897febfbe..4c281a5781 100644 --- a/builtin/stash.c +++ b/builtin/stash.c @@ -130,6 +130,24 @@ static void assert_stash_like(struct stash_info *info, const char *revision) die(_("'%s' is not a stash-like commit"), revision); } +static int parse_revision(struct strbuf *revision, const char *commit, int quiet) +{ + strbuf_init(revision, 0); + if (!commit) { + if (!ref_exists(ref_stash)) { + fprintf_ln(stderr, _("No stash entries found.")); + return -1; + } + + strbuf_addf(revision, "%s@{0}", ref_stash); + } else if (strspn(commit, "0123456789") == strlen(commit)) { + strbuf_addf(revision, "%s@{%s}", ref_stash, commit); + } else { + strbuf_addstr(revision, commit); + } + return 0; +} + static int get_stash_info(struct stash_info *info, int argc, const char **argv) { int ret; @@ -157,19 +175,9 @@ static int get_stash_info(struct stash_info *info, int argc, const char **argv) if (argc == 1) commit = argv[0]; - strbuf_init(&info->revision, 0); - if (!commit) { - if (!ref_exists(ref_stash)) { - free_stash_info(info); - fprintf_ln(stderr, _("No stash entries found.")); - return -1; - } - - strbuf_addf(&info->revision, "%s@{0}", ref_stash); - } else if (strspn(commit, "0123456789") == strlen(commit)) { - strbuf_addf(&info->revision, "%s@{%s}", ref_stash, commit); - } else { - strbuf_addstr(&info->revision, commit); + if (parse_revision(&info->revision, commit, 0)) { + free_stash_info(info); + return -1; } revision = info->revision.buf; From patchwork Tue Mar 29 21:49:40 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: "brian m. carlson" X-Patchwork-Id: 12795281 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 81DDDC433FE for ; Tue, 29 Mar 2022 21:50:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235312AbiC2Vvq (ORCPT ); Tue, 29 Mar 2022 17:51:46 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34226 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235045AbiC2Vvh (ORCPT ); Tue, 29 Mar 2022 17:51:37 -0400 Received: from ring.crustytoothpaste.net (ring.crustytoothpaste.net [IPv6:2600:3c04::f03c:92ff:fe9e:c6d8]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0FC8B47391 for ; Tue, 29 Mar 2022 14:49:52 -0700 (PDT) Received: from camp.crustytoothpaste.net (ipagstaticip-2d4b363b-56b8-9979-23b8-fd468af1db4c.sdsl.bell.ca [142.112.6.242]) (using TLSv1.2 with cipher ECDHE-RSA-CHACHA20-POLY1305 (256/256 bits)) (No client certificate requested) by ring.crustytoothpaste.net (Postfix) with ESMTPSA id F2D4F5A3DD; Tue, 29 Mar 2022 21:49:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=crustytoothpaste.net; s=default; t=1648590592; bh=BFFbQUHjxwrhTzSv6oXMeoFUtsKk1DA2f8z0eVzy3EQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:Content-Type:From: Reply-To:Subject:Date:To:CC:Resent-Date:Resent-From:Resent-To: Resent-Cc:In-Reply-To:References:Content-Type:Content-Disposition; b=1JqR3gAWwZE32uJgCLLOip1f3c9yaPBLE+R2UvHPY6VzSZBzkII64aoPquO2CogIe jYrVcs8qTCwVaTgh3yb2eHwvzXmEEoKyaDDzN2CeidHetGskruW7nmYk8zdylF0MdV ODay1GT6YjynqkfsFFI2T7coQE8yJj/t05CBKEp20G3bb/CM3rzaTvstv+cZoovV/v MxjpaSZAjhVOdceDy6aUd45dyoDBJPfkcZUXlzJCLp90lNYxynECrK5H6NgXtt0dvl rRnFnLcNZbJKfetKdYa8QtSCTK77fdDhZTCsQXVYJEa04WRSTV3qQgPTq9i/6BAfiU 66Nq5oYTO1vdXO4sxpOzVmF2Fb3X/GssrPUGmrOOVLEl6lqZGw4u3Gpia84T5GXzYL T85ue+2SJxE6ckdTQpQlGF94neHPROMvMQioI7bdH9Y3Ue/bvKJSjvCaAc9rKtpL9/ nE5UWkY0Kmn6H5zFEo9EgCxIelNCZskvjjVX7BNDKwnB+hrqawQ From: "brian m. carlson" To: Cc: Junio C Hamano , Phillip Wood , =?utf-8?b?w4Z2YXIgQXJuZmrDtnI=?= =?utf-8?b?w7AgQmphcm1hc29u?= Subject: [PATCH v2 3/4] builtin/stash: provide a way to export stashes to a ref Date: Tue, 29 Mar 2022 21:49:40 +0000 Message-Id: <20220329214941.2018609-4-sandals@crustytoothpaste.net> X-Mailer: git-send-email 2.35.1.473.g83b2b277ed In-Reply-To: <20220329214941.2018609-1-sandals@crustytoothpaste.net> References: <20220310173236.4165310-1-sandals@crustytoothpaste.net> <20220329214941.2018609-1-sandals@crustytoothpaste.net> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org A common user problem is how to sync in-progress work to another machine. Users currently must use some sort of transfer of the working tree, which poses security risks and also necessarily causes the index to become dirty. The experience is suboptimal and frustrating for users. A reasonable idea is to use the stash for this purpose, but the stash is stored in the reflog, not in a ref, and as such it cannot be pushed or pulled. This also means that it cannot be saved into a bundle or preserved elsewhere, which is a problem when using throwaway development environments. Let's solve this problem by allowing the user to export the stash to a ref (or, to just write it into the repository and print the hash, à la git commit-tree). Introduce git stash export, which writes a chain of commits where the first parent is always a chain to the previous stash, or to a single, empty commit (for the final item) and the second is the stash commit normally written to the reflog. Iterate over each stash from topmost to bottomost, looking up the data for each one, and then create the chain from the single empty commit back up in reverse order. Generate a predictable empty commit so our behavior is reproducible. Create a useful commit message, preserving the author and committer information, to help users identify stash commits when viewing them as normal commits. If the user has specified specific stashes they'd like to export instead, use those instead of iterating over all of the stashes. As part of this, specifically request quiet behavior when looking up the OID for a revision because we will eventually hit a revision that doesn't exist and we don't want to die when that occurs. Signed-off-by: brian m. carlson --- Documentation/git-stash.txt | 22 ++++- builtin/stash.c | 183 ++++++++++++++++++++++++++++++++++++ 2 files changed, 204 insertions(+), 1 deletion(-) diff --git a/Documentation/git-stash.txt b/Documentation/git-stash.txt index 6e15f47525..162110314e 100644 --- a/Documentation/git-stash.txt +++ b/Documentation/git-stash.txt @@ -20,6 +20,7 @@ SYNOPSIS 'git stash' clear 'git stash' create [] 'git stash' store [-m|--message ] [-q|--quiet] +'git stash' export ( --print | --to-ref ) [...] DESCRIPTION ----------- @@ -151,6 +152,12 @@ store:: reflog. This is intended to be useful for scripts. It is probably not the command you want to use; see "push" above. +export ( --print | --to-ref ) [...]:: + + Export the specified stashes, or all of them if none are specified, to + a chain of commits which can be transferred using the normal fetch and + push mechanisms, then imported using the `import` subcommand. + OPTIONS ------- -a:: @@ -239,6 +246,19 @@ literally (including newlines and quotes). + Quiet, suppress feedback messages. +--print:: + This option is only valid for `export`. ++ +Create the chain of commits representing the exported stashes without +storing it anywhere in the ref namespace and print the object ID to +standard output. This is designed for scripts. + +--to-ref:: + This option is only valid for `export`. ++ +Create the chain of commits representing the exported stashes and store +it to the specified ref. + \--:: This option is only valid for `push` command. + @@ -256,7 +276,7 @@ For more details, see the 'pathspec' entry in linkgit:gitglossary[7]. :: This option is only valid for `apply`, `branch`, `drop`, `pop`, - `show` commands. + `show`, and `export` commands. + A reference of the form `stash@{}`. When no `` is given, the latest stash is assumed (that is, `stash@{0}`). diff --git a/builtin/stash.c b/builtin/stash.c index 4c281a5781..6f1fa19172 100644 --- a/builtin/stash.c +++ b/builtin/stash.c @@ -33,6 +33,7 @@ static const char * const git_stash_usage[] = { " [--] [...]]"), N_("git stash save [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-q|--quiet]\n" " [-u|--include-untracked] [-a|--all] []"), + N_("git stash export (--print | --to-ref ) [...]"), NULL }; @@ -89,6 +90,12 @@ static const char * const git_stash_save_usage[] = { NULL }; +static const char * const git_stash_export_usage[] = { + N_("git stash export (--print | --to-ref ) [...]"), + NULL +}; + + static const char ref_stash[] = "refs/stash"; static struct strbuf stash_index_path = STRBUF_INIT; @@ -1773,6 +1780,180 @@ static int save_stash(int argc, const char **argv, const char *prefix) return ret; } +static int write_commit_with_parents(struct object_id *out, const struct object_id *oid, struct commit_list *parents) +{ + size_t author_len, committer_len; + struct commit *this; + const char *orig_author, *orig_committer; + char *author = NULL, *committer = NULL; + const char *buffer; + unsigned long bufsize; + const char *p; + struct strbuf msg = STRBUF_INIT; + int ret = 0; + + this = lookup_commit_reference(the_repository, oid); + buffer = get_commit_buffer(this, &bufsize); + orig_author = find_commit_header(buffer, "author", &author_len); + orig_committer = find_commit_header(buffer, "committer", &committer_len); + p = memmem(buffer, bufsize, "\n\n", 2); + + if (!orig_author || !orig_committer || !p) { + error(_("cannot parse commit %s"), oid_to_hex(oid)); + goto out; + } + /* Jump to message. */ + p += 2; + strbuf_addstr(&msg, "git stash: "); + strbuf_add(&msg, p, bufsize - (p - buffer)); + + author = xmemdupz(orig_author, author_len); + committer = xmemdupz(orig_committer, committer_len); + + if (commit_tree_extended(msg.buf, msg.len, + the_hash_algo->empty_tree, parents, + out, author, committer, + NULL, NULL)) { + ret = -1; + error(_("could not write commit")); + goto out; + } +out: + strbuf_reset(&msg); + unuse_commit_buffer(this, buffer); + free(author); + free(committer); + return ret; +} + +static int do_export_stash(const char *ref, size_t argc, const char **argv) +{ + struct object_id base; + struct object_context unused; + struct commit *prev; + struct object_id *items = NULL; + int nitems = 0, nalloc = 0; + int res = 0; + struct strbuf revision; + const char *author, *committer; + + /* + * This is an arbitrary, fixed date, specifically the one used by git + * format-patch. The goal is merely to produce reproducible output. + */ + prepare_fallback_ident("git stash", "git@stash"); + author = fmt_ident("git stash", "git@stash", WANT_BLANK_IDENT, "2001-09-17T00:00:00Z", 0); + committer = fmt_ident("git stash", "git@stash", WANT_BLANK_IDENT, "2001-09-17T00:00:00Z", 0); + + /* First, we create a single empty commit. */ + if (commit_tree_extended(NULL, 0, the_hash_algo->empty_tree, NULL, &base, author, committer, NULL, NULL)) + return error(_("unable to write base commit")); + + prev = lookup_commit_reference(the_repository, &base); + + if (argc) { + /* + * Find each specified stash, and load data into the array. + */ + for (int i = 0; i < argc; i++) { + ALLOC_GROW_BY(items, nitems, 1, nalloc); + if (parse_revision(&revision, argv[i], 0) || + get_oid_with_context(the_repository, revision.buf, + GET_OID_QUIETLY | GET_OID_GENTLY, + &items[i], &unused)) { + error(_("unable to find stash entry %s"), argv[i]); + res = -1; + goto out; + } + } + } else { + /* + * Walk the reflog, finding each stash entry, and load data into the + * array. + */ + for (int i = 0;; i++) { + char buf[32]; + struct object_id oid; + + snprintf(buf, sizeof(buf), "%d", i); + if (parse_revision(&revision, buf, 1) || + get_oid_with_context(the_repository, revision.buf, + GET_OID_QUIETLY | GET_OID_GENTLY, + &oid, &unused)) + break; + ALLOC_GROW_BY(items, nitems, 1, nalloc); + oidcpy(&items[i], &oid); + } + } + + /* + * Now, create a set of commits identical to the regular stash commits, + * but where their first parents form a chain to our original empty + * base commit. + */ + for (int i = nitems - 1; i >= 0; i--) { + struct commit_list *parents = NULL; + struct commit_list **next = &parents; + struct object_id out; + + next = commit_list_append(prev, next); + next = commit_list_append(lookup_commit_reference(the_repository, &items[i]), next); + if (write_commit_with_parents(&out, &items[i], parents)) { + res = -1; + goto out; + } + prev = lookup_commit_reference(the_repository, &out); + } + if (ref) + update_ref(NULL, ref, &prev->object.oid, NULL, 0, UPDATE_REFS_DIE_ON_ERR); + else + puts(oid_to_hex(&prev->object.oid)); +out: + free(items); + + return res; +} + +enum export_action { + ACTION_NONE, + ACTION_PRINT, + ACTION_TO_REF, +}; + +static int export_stash(int argc, const char **argv, const char *prefix) +{ + int ret = 0; + const char *ref = NULL; + enum export_action action = ACTION_NONE; + struct option options[] = { + OPT_CMDMODE(0, "print", &action, + N_("print the object ID instead of writing it to a ref"), + ACTION_PRINT), + OPT_CMDMODE(0, "to-ref", &action, + N_("save the data to the given ref"), + ACTION_TO_REF), + OPT_END() + }; + + argc = parse_options(argc, argv, prefix, options, + git_stash_export_usage, + PARSE_OPT_KEEP_DASHDASH); + + if (action == ACTION_NONE) { + return error(_("exactly one of --print and --to-ref is required")); + } else if (action == ACTION_TO_REF) { + if (!argc) + return error(_("--to-ref requires an argument")); + ref = argv[0]; + argc--; + argv++; + } + + + ret = do_export_stash(ref, argc, argv); + return ret; +} + int cmd_stash(int argc, const char **argv, const char *prefix) { pid_t pid = getpid(); @@ -1816,6 +1997,8 @@ int cmd_stash(int argc, const char **argv, const char *prefix) return !!push_stash(argc, argv, prefix, 0); else if (!strcmp(argv[0], "save")) return !!save_stash(argc, argv, prefix); + else if (!strcmp(argv[0], "export")) + return !!export_stash(argc, argv, prefix); else if (*argv[0] != '-') usage_msg_optf(_("unknown subcommand: %s"), git_stash_usage, options, argv[0]); From patchwork Tue Mar 29 21:49:41 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "brian m. carlson" X-Patchwork-Id: 12795280 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CB130C433F5 for ; Tue, 29 Mar 2022 21:50:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235100AbiC2Vvo (ORCPT ); Tue, 29 Mar 2022 17:51:44 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34202 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235019AbiC2Vvh (ORCPT ); Tue, 29 Mar 2022 17:51:37 -0400 Received: from ring.crustytoothpaste.net (ring.crustytoothpaste.net [IPv6:2600:3c04::f03c:92ff:fe9e:c6d8]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D1E5E47384 for ; Tue, 29 Mar 2022 14:49:52 -0700 (PDT) Received: from camp.crustytoothpaste.net (ipagstaticip-2d4b363b-56b8-9979-23b8-fd468af1db4c.sdsl.bell.ca [142.112.6.242]) (using TLSv1.2 with cipher ECDHE-RSA-CHACHA20-POLY1305 (256/256 bits)) (No client certificate requested) by ring.crustytoothpaste.net (Postfix) with ESMTPSA id 122105A3DE; Tue, 29 Mar 2022 21:49:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=crustytoothpaste.net; s=default; t=1648590592; bh=U7FRdcb5bz76UIYpKN5zUz2Oaqwv4oKTfA/XpaoSfSg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From:Reply-To: Subject:Date:To:CC:Resent-Date:Resent-From:Resent-To:Resent-Cc: In-Reply-To:References:Content-Type:Content-Disposition; b=yMf7KPKd+VfVpIhNojmixKvnHvMGZzQ0QDmDHqvRntrxF5/1N2yGm2hMuysCQCpjG y+cz0lQNMLclxUCfLPHbsxwzm4r5l7vq5rqygN4fZZKIrbKT9IXfQK0CJG7x8lUfBw yyCeUmZaThl1GXNeMGEjl8XK/HD2jIpakVbi6FILg9n6eFjJl6v8XP3MxitOWtXx2i Sl8FJHrax8fsk1RcNaAIQdckk2/JIufDvyc5lwLuhPZF1zjcSLIs0229yT7fMuWQGB 4oqepch5xx+zhoe84n8qFIhCMIbrwJccaBXT3WX+7Lj0MrEFYMeS3wh5VsFuxTn9/p lXBQHfn+HY87zJSVCPqn74GLtwzkz8PMx/gXL9b/1ZnGUZ1waWwglwAqt+KikhUZrI iaRjPW3WmsAJrgTN5P9VjvU6FWw+GAo9II684pMYxB6u4e3GpISmXGSEYZYKCLo0D6 d0OAwfOKPDU0BGXDxIkOrU0XFfQFU0xFzs4cCzrlYGPrChVYjis From: "brian m. carlson" To: Cc: Junio C Hamano , Phillip Wood , =?utf-8?b?w4Z2YXIgQXJuZmrDtnI=?= =?utf-8?b?w7AgQmphcm1hc29u?= Subject: [PATCH v2 4/4] builtin/stash: provide a way to import stashes from a ref Date: Tue, 29 Mar 2022 21:49:41 +0000 Message-Id: <20220329214941.2018609-5-sandals@crustytoothpaste.net> X-Mailer: git-send-email 2.35.1.473.g83b2b277ed In-Reply-To: <20220329214941.2018609-1-sandals@crustytoothpaste.net> References: <20220310173236.4165310-1-sandals@crustytoothpaste.net> <20220329214941.2018609-1-sandals@crustytoothpaste.net> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org Now that we have a way to export stashes to a ref, let's provide a way to import them from such a ref back to the stash. This works much the way the export code does, except that we strip off the first parent chain commit and then store each resulting commit back to the stash. We don't clear the stash first and instead add the specified stashes to the top of the stash. This is because users may want to export just a few stashes, such as to share a small amount of work in progress with a colleague, and it would be undesirable for the receiving user to lose all of their data. For users who do want to replace the stash, it's easy to do to: simply run "git stash clear" first. We specifically rely on the fact that we'll produce identical stash commits on both sides in our tests. This provides a cheap, straightforward check for our tests and also makes it easy for users to see if they already have the same data in both repositories. Signed-off-by: brian m. carlson --- Documentation/git-stash.txt | 7 +++ builtin/stash.c | 107 ++++++++++++++++++++++++++++++++++++ t/t3903-stash.sh | 52 ++++++++++++++++++ 3 files changed, 166 insertions(+) diff --git a/Documentation/git-stash.txt b/Documentation/git-stash.txt index 162110314e..28eb9cab0c 100644 --- a/Documentation/git-stash.txt +++ b/Documentation/git-stash.txt @@ -21,6 +21,7 @@ SYNOPSIS 'git stash' create [] 'git stash' store [-m|--message ] [-q|--quiet] 'git stash' export ( --print | --to-ref ) [...] +'git stash' import DESCRIPTION ----------- @@ -158,6 +159,12 @@ export ( --print | --to-ref ) [...]:: a chain of commits which can be transferred using the normal fetch and push mechanisms, then imported using the `import` subcommand. +import :: + + Import the specified stashes from the specified commit, which must have been + created by `export`, and add them to the list of stashes. To replace the + existing stashes, use `clear` first. + OPTIONS ------- -a:: diff --git a/builtin/stash.c b/builtin/stash.c index 6f1fa19172..4b198f1ab7 100644 --- a/builtin/stash.c +++ b/builtin/stash.c @@ -34,6 +34,7 @@ static const char * const git_stash_usage[] = { N_("git stash save [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-q|--quiet]\n" " [-u|--include-untracked] [-a|--all] []"), N_("git stash export (--print | --to-ref ) [...]"), + N_("git stash import "), NULL }; @@ -95,6 +96,10 @@ static const char * const git_stash_export_usage[] = { NULL }; +static const char * const git_stash_import_usage[] = { + N_("git stash import "), + NULL +}; static const char ref_stash[] = "refs/stash"; static struct strbuf stash_index_path = STRBUF_INIT; @@ -104,6 +109,7 @@ static struct strbuf stash_index_path = STRBUF_INIT; * b_commit is set to the base commit * i_commit is set to the commit containing the index tree * u_commit is set to the commit containing the untracked files tree + * c_commit is set to the first parent (chain commit) when importing and is otherwise unset * w_tree is set to the working tree * b_tree is set to the base tree * i_tree is set to the index tree @@ -114,6 +120,7 @@ struct stash_info { struct object_id b_commit; struct object_id i_commit; struct object_id u_commit; + struct object_id c_commit; struct object_id w_tree; struct object_id b_tree; struct object_id i_tree; @@ -1826,6 +1833,104 @@ static int write_commit_with_parents(struct object_id *out, const struct object_ return ret; } +static int do_import_stash(const char *rev) +{ + struct object_id chain; + size_t nalloc = 0; + struct object_id *items = NULL; + int nitems = 0; + int res = 0; + const char *buffer = NULL; + struct commit *this = NULL; + char *msg = NULL; + + if (get_oid(rev, &chain)) + return error(_("not a valid revision: %s"), rev); + + /* + * Walk the commit history, finding each stash entry, and load data into + * the array. + */ + for (int i = 0;; i++) { + struct object_id tree, oid; + char revision[GIT_MAX_HEXSZ + 1]; + + oid_to_hex_r(revision, &chain); + + if (get_oidf(&tree, "%s:", revision) || + !oideq(&tree, the_hash_algo->empty_tree)) { + return error(_("%s is not a valid exported stash commit"), revision); + } + if (get_oidf(&chain, "%s^1", revision) || + get_oidf(&oid, "%s^2", revision)) + break; + ALLOC_GROW_BY(items, nitems, 1, nalloc); + oidcpy(&items[i], &oid); + } + + /* + * Now, walk each entry, adding it to the stash as a normal stash + * commit. + */ + for (int i = nitems - 1; i >= 0; i--) { + unsigned long bufsize; + const char *p; + + this = lookup_commit_reference(the_repository, &items[i]); + buffer = get_commit_buffer(this, &bufsize); + if (!buffer) { + res = -1; + error(_("cannot read commit buffer for %s"), oid_to_hex(&items[i])); + goto out; + } + + p = memmem(buffer, bufsize, "\n\n", 2); + if (!p) { + res = -1; + error(_("cannot parse commit %s"), oid_to_hex(&items[i])); + goto out; + } + + p += 2; + msg = xmemdupz(p, bufsize - (p - buffer)); + unuse_commit_buffer(this, buffer); + buffer = NULL; + + if (do_store_stash(&items[i], msg, 1)) { + res = -1; + error(_("cannot save the stash for %s"), oid_to_hex(&items[i])); + goto out; + } + FREE_AND_NULL(msg); + } +out: + if (this && buffer) + unuse_commit_buffer(this, buffer); + free(items); + free(msg); + + return res; +} + +static int import_stash(int argc, const char **argv, const char *prefix) +{ + int ret = 0; + struct option options[] = { + OPT_END() + }; + + argc = parse_options(argc, argv, prefix, options, + git_stash_import_usage, + PARSE_OPT_KEEP_DASHDASH); + + if (argc != 1) + return error(_("a revision to import from is required")); + + + ret = do_import_stash(argv[0]); + return ret; +} + static int do_export_stash(const char *ref, size_t argc, const char **argv) { struct object_id base; @@ -1999,6 +2104,8 @@ int cmd_stash(int argc, const char **argv, const char *prefix) return !!save_stash(argc, argv, prefix); else if (!strcmp(argv[0], "export")) return !!export_stash(argc, argv, prefix); + else if (!strcmp(argv[0], "import")) + return !!import_stash(argc, argv, prefix); else if (*argv[0] != '-') usage_msg_optf(_("unknown subcommand: %s"), git_stash_usage, options, argv[0]); diff --git a/t/t3903-stash.sh b/t/t3903-stash.sh index b149e2af44..d2ddede9be 100755 --- a/t/t3903-stash.sh +++ b/t/t3903-stash.sh @@ -1295,6 +1295,58 @@ test_expect_success 'stash --keep-index with file deleted in index does not resu test_path_is_missing to-remove ' +test_expect_success 'stash export and import round-trip stashes' ' + git reset && + >untracked && + >tracked1 && + >tracked2 && + git add tracked* && + git stash -- && + >subdir/untracked && + >subdir/tracked1 && + >subdir/tracked2 && + git add subdir/tracked* && + git stash -- subdir/ && + stash0=$(git rev-parse --verify stash@{0}) && + stash1=$(git rev-parse --verify stash@{1}) && + simple=$(git stash export --print) && + git stash clear && + git stash import "$simple" && + imported0=$(git rev-parse --verify stash@{0}) && + imported1=$(git rev-parse --verify stash@{1}) && + test "$imported0" = "$stash0" && + test "$imported1" = "$stash1" && + git stash export --to-ref refs/heads/foo && + git stash clear && + git stash import foo && + imported0=$(git rev-parse --verify stash@{0}) && + imported1=$(git rev-parse --verify stash@{1}) && + test "$imported0" = "$stash0" && + test "$imported1" = "$stash1" +' + +test_expect_success 'stash import appends commits' ' + git log --format=oneline -g refs/stash >actual && + echo $(cat actual | wc -l) >count && + git stash import refs/heads/foo && + git log --format=oneline -g refs/stash >actual && + test_line_count = $(($(cat count) * 2)) actual +' + +test_expect_success 'stash export can accept specified stashes' ' + git stash clear && + git stash import foo && + git stash export --to-ref bar stash@{1} stash@{0} && + git stash clear && + git stash import bar && + imported0=$(git rev-parse --verify stash@{0}) && + imported1=$(git rev-parse --verify stash@{1}) && + test "$imported1" = "$stash0" && + test "$imported0" = "$stash1" && + git log --format=oneline -g refs/stash >actual && + test_line_count = 2 actual +' + test_expect_success 'stash apply should succeed with unmodified file' ' echo base >file && git add file &&