Skip to contentSkip to conversation

sha1-name.c: add `get_oidf()` which acts like `get_oid()`

PATCH Superseded Paul-Sebastian Ungureanu 4 participants 30 messages Oct 14, 2018 – Oct 16, 2018 1 message not in the archive

Subsystems (2)

v10 of 12 Superseded Latest is v12 →

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): https://public-inbox.org/git/[email protected]/

#1 lore raw

v10 cover Convert "git stash" to C builtin

Hello,

This is a new iteration of git stash, based on the last review. This iteration fixes some code styling issues, bring some changes to do_push_stash() and do_create_stash() to be closer to API by following Thomas Gummerer's review of last iteration [1]. Also, there were some missing messages [2], which are now included.

[1]
https://public-inbox.org/git/[email protected]/

[2]
https://github.com/git-for-windows/git/commit/2af24038a95a3879aa0c29d91a43180b9465247e

Joel Teichroeb (5):
stash: improve option parsing test coverage
stash: convert apply to builtin
stash: convert drop and clear to builtin
stash: convert branch to builtin
stash: convert pop to builtin

Paul-Sebastian Ungureanu (16):
sha1-name.c: add get_oidf() which acts like get_oid() strbuf.c: add strbuf_join_argv()
t3903: modernize style
stash: rename test cases to be more descriptive
stash: add tests for git stash show config
stash: mention options in show synopsis
stash: convert list to builtin
stash: convert show to builtin
stash: convert store to builtin
stash: convert create to builtin
stash: convert push to builtin
stash: make push -q quiet
stash: convert save to builtin
stash: convert stash--helper.c into stash.c
stash: optimize get_untracked_files() and check_changes()
stash: replace all write-tree child processes with API calls

 Documentation/git-stash.txt  |    4 +-
 Makefile                     |    2 +-
 builtin.h                    |    1 +
 builtin/stash.c              | 1605 ++++++++++++++++++++++++++++++++++
 cache.h                      |    1 +
 git-stash.sh                 |  752 ----------------
 git.c                        |    1 +
 sha1-name.c                  |   19 +
 strbuf.c                     |   13 +
 strbuf.h                     |    7 +
 t/t3903-stash.sh             |  192 ++--
 t/t3907-stash-show-config.sh |   83 ++
 12 files changed, 1859 insertions(+), 821 deletions(-)
 create mode 100644 builtin/stash.c
 delete mode 100755 git-stash.sh
 create mode 100755 t/t3907-stash-show-config.sh
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#2 lore raw

PATCH v10 1/21 sha1-name.c: add `get_oidf()` which acts like `get_oid()`

Compared to get_oid(), get_oidf() has as parameters a pointer to object_id, a printf format string and additional arguments. This will help simplify the code in subsequent commits.

---
 cache.h     |  1 +
 sha1-name.c | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+)
cache.h +1 -0
index b1fd3d58ab..d93b2e25a5 100644
@@ -1309,6 +1309,7 @@ struct object_context {
 	GET_OID_BLOB)
 
 extern int get_oid(const char *str, struct object_id *oid);
+extern int get_oidf(struct object_id *oid, const char *fmt, ...);
 extern int get_oid_commit(const char *str, struct object_id *oid);
 extern int get_oid_committish(const char *str, struct object_id *oid);
 extern int get_oid_tree(const char *str, struct object_id *oid);
sha1-name.c +19 -0
index c9cc1318b7..261b960bbd 100644
@@ -1471,6 +1471,25 @@ int get_oid(const char *name, struct object_id *oid)
 	return get_oid_with_context(name, 0, oid, &unused);
 }
 
+/*
+ * This returns a non-zero value if the string (built using printf
+ * format and the given arguments) is not a valid object.
+ */
+int get_oidf(struct object_id *oid, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+	struct strbuf sb = STRBUF_INIT;
+
+	va_start(ap, fmt);
+	strbuf_vaddf(&sb, fmt, ap);
+	va_end(ap);
+
+	ret = get_oid(sb.buf, oid);
+	strbuf_release(&sb);
+
+	return ret;
+}
 
 /*
  * Many callers know that the user meant to name a commit-ish by
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#3 lore raw

PATCH v10 2/21 strbuf.c: add `strbuf_join_argv()`

In reply to Paul-Sebastian Ungureanu

Implement strbuf_join_argv() to join arguments
into a strbuf.

---
 strbuf.c | 13 +++++++++++++
 strbuf.h |  7 +++++++
 2 files changed, 20 insertions(+)
strbuf.c +13 -0
index 64041c3c24..c8a104099a 100644
@@ -259,6 +259,19 @@ void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2)
 	strbuf_setlen(sb, sb->len + sb2->len);
 }
 
+void strbuf_join_argv(struct strbuf *buf,
+		      int argc, const char **argv, char delim)
+{
+	if (!argc)
+		return;
+
+	strbuf_addstr(buf, *argv);
+	while (--argc) {
+		strbuf_addch(buf, delim);
+		strbuf_addstr(buf, *(++argv));
+	}
+}
+
 void strbuf_addchars(struct strbuf *sb, int c, size_t n)
 {
 	strbuf_grow(sb, n);
strbuf.h +7 -0
index 60a35aef16..4ec912f4b7 100644
@@ -284,6 +284,13 @@ static inline void strbuf_addstr(struct strbuf *sb, const char *s)
  */
 extern void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2);
 
+/**
+ * Join the arguments into a buffer. `delim` is put between every
+ * two arguments.
+ */
+extern void strbuf_join_argv(struct strbuf *buf, int argc,
+			     const char **argv, char delim);
+
 /**
  * This function can be used to expand a format string containing
  * placeholders. To that end, it parses the string and calls the specified
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#4 lore raw

PATCH v10 3/21 stash: improve option parsing test coverage

In reply to Paul-Sebastian Ungureanu

From: Joel Teichroeb <[email protected]>

In preparation for converting the stash command incrementally to a builtin command, this patch improves test coverage of the option parsing. Both for having too many parameters, or too few.

---
 t/t3903-stash.sh | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
t/t3903-stash.sh +35 -0
index 1f871d3cca..af7586d43d 100755
@@ -444,6 +444,36 @@ test_expect_failure 'stash file to directory' '
 	test foo = "$(cat file/file)"
 '
 
+test_expect_success 'giving too many ref arguments does not modify files' '
+	git stash clear &&
+	test_when_finished "git reset --hard HEAD" &&
+	echo foo >file2 &&
+	git stash &&
+	echo bar >file2 &&
+	git stash &&
+	test-tool chmtime =123456789 file2 &&
+	for type in apply pop "branch stash-branch"
+	do
+		test_must_fail git stash $type stash@{0} stash@{1} 2>err &&
+		test_i18ngrep "Too many revisions" err &&
+		test 123456789 = $(test-tool chmtime -g file2) || return 1
+	done
+'
+
+test_expect_success 'drop: too many arguments errors out (does nothing)' '
+	git stash list >expect &&
+	test_must_fail git stash drop stash@{0} stash@{1} 2>err &&
+	test_i18ngrep "Too many revisions" err &&
+	git stash list >actual &&
+	test_cmp expect actual
+'
+
+test_expect_success 'show: too many arguments errors out (does nothing)' '
+	test_must_fail git stash show stash@{0} stash@{1} 2>err 1>out &&
+	test_i18ngrep "Too many revisions" err &&
+	test_must_be_empty out
+'
+
 test_expect_success 'stash create - no changes' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD" &&
@@ -479,6 +509,11 @@ test_expect_success 'stash branch - stashes on stack, stash-like argument' '
 	test $(git ls-files --modified | wc -l) -eq 1
 '
 
+test_expect_success 'stash branch complains with no arguments' '
+	test_must_fail git stash branch 2>err &&
+	test_i18ngrep "No branch name specified" err
+'
+
 test_expect_success 'stash show format defaults to --stat' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD" &&
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#5 lore raw

PATCH v10 4/21 t3903: modernize style

In reply to Paul-Sebastian Ungureanu

Remove whitespaces after redirection operators and wrap long lines.

---
 t/t3903-stash.sh | 120 ++++++++++++++++++++++++-----------------------
 1 file changed, 61 insertions(+), 59 deletions(-)
t/t3903-stash.sh +61 -59
index af7586d43d..de6cab1fe7 100755
@@ -8,22 +8,22 @@ test_description='Test git stash'
 . ./test-lib.sh
 
 test_expect_success 'stash some dirty working directory' '
-	echo 1 > file &&
+	echo 1 >file &&
 	git add file &&
 	echo unrelated >other-file &&
 	git add other-file &&
 	test_tick &&
 	git commit -m initial &&
-	echo 2 > file &&
+	echo 2 >file &&
 	git add file &&
-	echo 3 > file &&
+	echo 3 >file &&
 	test_tick &&
 	git stash &&
 	git diff-files --quiet &&
 	git diff-index --cached --quiet HEAD
 '
 
-cat > expect << EOF
+cat >expect <<EOF
 diff --git a/file b/file
 index 0cfbf08..00750ed 100644
 --- a/file
@@ -35,7 +35,7 @@ EOF
 
 test_expect_success 'parents of stash' '
 	test $(git rev-parse stash^) = $(git rev-parse HEAD) &&
-	git diff stash^2..stash > output &&
+	git diff stash^2..stash >output &&
 	test_cmp output expect
 '
 
@@ -74,7 +74,7 @@ test_expect_success 'apply stashed changes' '
 
 test_expect_success 'apply stashed changes (including index)' '
 	git reset --hard HEAD^ &&
-	echo 6 > other-file &&
+	echo 6 >other-file &&
 	git add other-file &&
 	test_tick &&
 	git commit -m other-file &&
@@ -99,12 +99,12 @@ test_expect_success 'stash drop complains of extra options' '
 
 test_expect_success 'drop top stash' '
 	git reset --hard &&
-	git stash list > stashlist1 &&
-	echo 7 > file &&
+	git stash list >expected &&
+	echo 7 >file &&
 	git stash &&
 	git stash drop &&
-	git stash list > stashlist2 &&
-	test_cmp stashlist1 stashlist2 &&
+	git stash list >actual &&
+	test_cmp expected actual &&
 	git stash apply &&
 	test 3 = $(cat file) &&
 	test 1 = $(git show :file) &&
@@ -113,9 +113,9 @@ test_expect_success 'drop top stash' '
 
 test_expect_success 'drop middle stash' '
 	git reset --hard &&
-	echo 8 > file &&
+	echo 8 >file &&
 	git stash &&
-	echo 9 > file &&
+	echo 9 >file &&
 	git stash &&
 	git stash drop stash@{1} &&
 	test 2 = $(git stash list | wc -l) &&
@@ -160,7 +160,7 @@ test_expect_success 'stash pop' '
 	test 0 = $(git stash list | wc -l)
 '
 
-cat > expect << EOF
+cat >expect <<EOF
 diff --git a/file2 b/file2
 new file mode 100644
 index 0000000..1fe912c
@@ -170,7 +170,7 @@ index 0000000..1fe912c
 +bar2
 EOF
 
-cat > expect1 << EOF
+cat >expect1 <<EOF
 diff --git a/file b/file
 index 257cc56..5716ca5 100644
 --- a/file
@@ -180,7 +180,7 @@ index 257cc56..5716ca5 100644
 +bar
 EOF
 
-cat > expect2 << EOF
+cat >expect2 <<EOF
 diff --git a/file b/file
 index 7601807..5716ca5 100644
 --- a/file
@@ -198,79 +198,79 @@ index 0000000..1fe912c
 EOF
 
 test_expect_success 'stash branch' '
-	echo foo > file &&
+	echo foo >file &&
 	git commit file -m first &&
-	echo bar > file &&
-	echo bar2 > file2 &&
+	echo bar >file &&
+	echo bar2 >file2 &&
 	git add file2 &&
 	git stash &&
-	echo baz > file &&
+	echo baz >file &&
 	git commit file -m second &&
 	git stash branch stashbranch &&
 	test refs/heads/stashbranch = $(git symbolic-ref HEAD) &&
 	test $(git rev-parse HEAD) = $(git rev-parse master^) &&
-	git diff --cached > output &&
+	git diff --cached >output &&
 	test_cmp output expect &&
-	git diff > output &&
+	git diff >output &&
 	test_cmp output expect1 &&
 	git add file &&
 	git commit -m alternate\ second &&
-	git diff master..stashbranch > output &&
+	git diff master..stashbranch >output &&
 	test_cmp output expect2 &&
 	test 0 = $(git stash list | wc -l)
 '
 
 test_expect_success 'apply -q is quiet' '
-	echo foo > file &&
+	echo foo >file &&
 	git stash &&
-	git stash apply -q > output.out 2>&1 &&
+	git stash apply -q >output.out 2>&1 &&
 	test_must_be_empty output.out
 '
 
 test_expect_success 'save -q is quiet' '
-	git stash save --quiet > output.out 2>&1 &&
+	git stash save --quiet >output.out 2>&1 &&
 	test_must_be_empty output.out
 '
 
 test_expect_success 'pop -q is quiet' '
-	git stash pop -q > output.out 2>&1 &&
+	git stash pop -q >output.out 2>&1 &&
 	test_must_be_empty output.out
 '
 
 test_expect_success 'pop -q --index works and is quiet' '
-	echo foo > file &&
+	echo foo >file &&
 	git add file &&
 	git stash save --quiet &&
-	git stash pop -q --index > output.out 2>&1 &&
+	git stash pop -q --index >output.out 2>&1 &&
 	test foo = "$(git show :file)" &&
 	test_must_be_empty output.out
 '
 
 test_expect_success 'drop -q is quiet' '
 	git stash &&
-	git stash drop -q > output.out 2>&1 &&
+	git stash drop -q >output.out 2>&1 &&
 	test_must_be_empty output.out
 '
 
 test_expect_success 'stash -k' '
-	echo bar3 > file &&
-	echo bar4 > file2 &&
+	echo bar3 >file &&
+	echo bar4 >file2 &&
 	git add file2 &&
 	git stash -k &&
 	test bar,bar4 = $(cat file),$(cat file2)
 '
 
 test_expect_success 'stash --no-keep-index' '
-	echo bar33 > file &&
-	echo bar44 > file2 &&
+	echo bar33 >file &&
+	echo bar44 >file2 &&
 	git add file2 &&
 	git stash --no-keep-index &&
 	test bar,bar2 = $(cat file),$(cat file2)
 '
 
 test_expect_success 'stash --invalid-option' '
-	echo bar5 > file &&
-	echo bar6 > file2 &&
+	echo bar5 >file &&
+	echo bar6 >file2 &&
 	git add file2 &&
 	test_must_fail git stash --invalid-option &&
 	test_must_fail git stash save --invalid-option &&
@@ -486,11 +486,12 @@ test_expect_success 'stash branch - no stashes on stack, stash-like argument' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD" &&
 	git reset --hard &&
-	echo foo >> file &&
+	echo foo >>file &&
 	STASH_ID=$(git stash create) &&
 	git reset --hard &&
 	git stash branch stash-branch ${STASH_ID} &&
-	test_when_finished "git reset --hard HEAD && git checkout master && git branch -D stash-branch" &&
+	test_when_finished "git reset --hard HEAD && git checkout master &&
+	git branch -D stash-branch" &&
 	test $(git ls-files --modified | wc -l) -eq 1
 '
 
@@ -498,14 +499,15 @@ test_expect_success 'stash branch - stashes on stack, stash-like argument' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD" &&
 	git reset --hard &&
-	echo foo >> file &&
+	echo foo >>file &&
 	git stash &&
 	test_when_finished "git stash drop" &&
-	echo bar >> file &&
+	echo bar >>file &&
 	STASH_ID=$(git stash create) &&
 	git reset --hard &&
 	git stash branch stash-branch ${STASH_ID} &&
-	test_when_finished "git reset --hard HEAD && git checkout master && git branch -D stash-branch" &&
+	test_when_finished "git reset --hard HEAD && git checkout master &&
+	git branch -D stash-branch" &&
 	test $(git ls-files --modified | wc -l) -eq 1
 '
 
@@ -518,10 +520,10 @@ test_expect_success 'stash show format defaults to --stat' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD" &&
 	git reset --hard &&
-	echo foo >> file &&
+	echo foo >>file &&
 	git stash &&
 	test_when_finished "git stash drop" &&
-	echo bar >> file &&
+	echo bar >>file &&
 	STASH_ID=$(git stash create) &&
 	git reset --hard &&
 	cat >expected <<-EOF &&
@@ -536,10 +538,10 @@ test_expect_success 'stash show - stashes on stack, stash-like argument' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD" &&
 	git reset --hard &&
-	echo foo >> file &&
+	echo foo >>file &&
 	git stash &&
 	test_when_finished "git stash drop" &&
-	echo bar >> file &&
+	echo bar >>file &&
 	STASH_ID=$(git stash create) &&
 	git reset --hard &&
 	echo "1	0	file" >expected &&
@@ -551,10 +553,10 @@ test_expect_success 'stash show -p - stashes on stack, stash-like argument' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD" &&
 	git reset --hard &&
-	echo foo >> file &&
+	echo foo >>file &&
 	git stash &&
 	test_when_finished "git stash drop" &&
-	echo bar >> file &&
+	echo bar >>file &&
 	STASH_ID=$(git stash create) &&
 	git reset --hard &&
 	cat >expected <<-EOF &&
@@ -574,7 +576,7 @@ test_expect_success 'stash show - no stashes on stack, stash-like argument' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD" &&
 	git reset --hard &&
-	echo foo >> file &&
+	echo foo >>file &&
 	STASH_ID=$(git stash create) &&
 	git reset --hard &&
 	echo "1	0	file" >expected &&
@@ -586,7 +588,7 @@ test_expect_success 'stash show -p - no stashes on stack, stash-like argument' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD" &&
 	git reset --hard &&
-	echo foo >> file &&
+	echo foo >>file &&
 	STASH_ID=$(git stash create) &&
 	git reset --hard &&
 	cat >expected <<-EOF &&
@@ -606,9 +608,9 @@ test_expect_success 'stash drop - fail early if specified stash is not a stash r
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD && git stash clear" &&
 	git reset --hard &&
-	echo foo > file &&
+	echo foo >file &&
 	git stash &&
-	echo bar > file &&
+	echo bar >file &&
 	git stash &&
 	test_must_fail git stash drop $(git rev-parse stash@{0}) &&
 	git stash pop &&
@@ -620,9 +622,9 @@ test_expect_success 'stash pop - fail early if specified stash is not a stash re
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD && git stash clear" &&
 	git reset --hard &&
-	echo foo > file &&
+	echo foo >file &&
 	git stash &&
-	echo bar > file &&
+	echo bar >file &&
 	git stash &&
 	test_must_fail git stash pop $(git rev-parse stash@{0}) &&
 	git stash pop &&
@@ -632,8 +634,8 @@ test_expect_success 'stash pop - fail early if specified stash is not a stash re
 
 test_expect_success 'ref with non-existent reflog' '
 	git stash clear &&
-	echo bar5 > file &&
-	echo bar6 > file2 &&
+	echo bar5 >file &&
+	echo bar6 >file2 &&
 	git add file2 &&
 	git stash &&
 	test_must_fail git rev-parse --quiet --verify does-not-exist &&
@@ -653,8 +655,8 @@ test_expect_success 'ref with non-existent reflog' '
 test_expect_success 'invalid ref of the form stash@{n}, n >= N' '
 	git stash clear &&
 	test_must_fail git stash drop stash@{0} &&
-	echo bar5 > file &&
-	echo bar6 > file2 &&
+	echo bar5 >file &&
+	echo bar6 >file2 &&
 	git add file2 &&
 	git stash &&
 	test_must_fail git stash drop stash@{1} &&
@@ -724,7 +726,7 @@ test_expect_success 'stash apply shows status same as git status (relative to cu
 	test_i18ncmp expect actual
 '
 
-cat > expect << EOF
+cat >expect <<EOF
 diff --git a/HEAD b/HEAD
 new file mode 100644
 index 0000000..fe0cbee
@@ -737,14 +739,14 @@ EOF
 test_expect_success 'stash where working directory contains "HEAD" file' '
 	git stash clear &&
 	git reset --hard &&
-	echo file-not-a-ref > HEAD &&
+	echo file-not-a-ref >HEAD &&
 	git add HEAD &&
 	test_tick &&
 	git stash &&
 	git diff-files --quiet &&
 	git diff-index --cached --quiet HEAD &&
 	test "$(git rev-parse stash^)" = "$(git rev-parse HEAD)" &&
-	git diff stash^..stash > output &&
+	git diff stash^..stash >output &&
 	test_cmp output expect
 '
 
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#6 lore raw

PATCH v10 5/21 stash: rename test cases to be more descriptive

In reply to Paul-Sebastian Ungureanu

Rename some test cases' labels to be more descriptive and under 80 characters per line.

---
 t/t3903-stash.sh | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)
t/t3903-stash.sh +7 -7
index de6cab1fe7..3114c7bc4c 100755
@@ -604,7 +604,7 @@ test_expect_success 'stash show -p - no stashes on stack, stash-like argument' '
 	test_cmp expected actual
 '
 
-test_expect_success 'stash drop - fail early if specified stash is not a stash reference' '
+test_expect_success 'drop: fail early if specified stash is not a stash ref' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD && git stash clear" &&
 	git reset --hard &&
@@ -618,7 +618,7 @@ test_expect_success 'stash drop - fail early if specified stash is not a stash r
 	git reset --hard HEAD
 '
 
-test_expect_success 'stash pop - fail early if specified stash is not a stash reference' '
+test_expect_success 'pop: fail early if specified stash is not a stash ref' '
 	git stash clear &&
 	test_when_finished "git reset --hard HEAD && git stash clear" &&
 	git reset --hard &&
@@ -682,7 +682,7 @@ test_expect_success 'invalid ref of the form "n", n >= N' '
 	git stash drop
 '
 
-test_expect_success 'stash branch should not drop the stash if the branch exists' '
+test_expect_success 'branch: do not drop the stash if the branch exists' '
 	git stash clear &&
 	echo foo >file &&
 	git add file &&
@@ -693,7 +693,7 @@ test_expect_success 'stash branch should not drop the stash if the branch exists
 	git rev-parse stash@{0} --
 '
 
-test_expect_success 'stash branch should not drop the stash if the apply fails' '
+test_expect_success 'branch: should not drop the stash if the apply fails' '
 	git stash clear &&
 	git reset HEAD~1 --hard &&
 	echo foo >file &&
@@ -707,7 +707,7 @@ test_expect_success 'stash branch should not drop the stash if the apply fails'
 	git rev-parse stash@{0} --
 '
 
-test_expect_success 'stash apply shows status same as git status (relative to current directory)' '
+test_expect_success 'apply: show same status as git status (relative to ./)' '
 	git stash clear &&
 	echo 1 >subdir/subfile1 &&
 	echo 2 >subdir/subfile2 &&
@@ -1048,7 +1048,7 @@ test_expect_success 'stash push -p with pathspec shows no changes only once' '
 	test_i18ncmp expect actual
 '
 
-test_expect_success 'stash push with pathspec shows no changes when there are none' '
+test_expect_success 'push <pathspec>: show no changes when there are none' '
 	>foo &&
 	git add foo &&
 	git commit -m "tmp" &&
@@ -1058,7 +1058,7 @@ test_expect_success 'stash push with pathspec shows no changes when there are no
 	test_i18ncmp expect actual
 '
 
-test_expect_success 'stash push with pathspec not in the repository errors out' '
+test_expect_success 'push: <pathspec> not in the repository errors out' '
 	>untracked &&
 	test_must_fail git stash push untracked &&
 	test_path_is_file untracked
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#7 lore raw

PATCH v10 6/21 stash: add tests for `git stash show` config

In reply to Paul-Sebastian Ungureanu

This commit introduces tests for git stash show config. It tests all the cases where stash.showStat and stash.showPatch are unset or set to true / false.

---
 t/t3907-stash-show-config.sh | 83 ++++++++++++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100755 t/t3907-stash-show-config.sh
t/t3907-stash-show-config.sh new file +83 -0
new file mode 100755
index 0000000000..10914bba7b
@@ -0,0 +1,83 @@
+#!/bin/sh
+
+test_description='Test git stash show configuration.'
+
+. ./test-lib.sh
+
+test_expect_success 'setup' '
+	test_commit file
+'
+
+# takes three parameters:
+# 1. the stash.showStat value (or "<unset>")
+# 2. the stash.showPatch value (or "<unset>")
+# 3. the diff options of the expected output (or nothing for no output)
+test_stat_and_patch () {
+	if test "<unset>" = "$1"
+	then
+		test_unconfig stash.showStat
+	else
+		test_config stash.showStat "$1"
+	fi &&
+
+	if test "<unset>" = "$2"
+	then
+		test_unconfig stash.showPatch
+	else
+		test_config stash.showPatch "$2"
+	fi &&
+
+	shift 2 &&
+	echo 2 >file.t &&
+	if test $# != 0
+	then
+		git diff "$@" >expect
+	fi &&
+	git stash &&
+	git stash show >actual &&
+
+	if test $# = 0
+	then
+		test_must_be_empty actual
+	else
+		test_cmp expect actual
+	fi
+}
+
+test_expect_success 'showStat unset showPatch unset' '
+	test_stat_and_patch "<unset>" "<unset>" --stat
+'
+
+test_expect_success 'showStat unset showPatch false' '
+	test_stat_and_patch "<unset>" false --stat
+'
+
+test_expect_success 'showStat unset showPatch true' '
+	test_stat_and_patch "<unset>" true --stat -p
+'
+
+test_expect_success 'showStat false showPatch unset' '
+	test_stat_and_patch false "<unset>"
+'
+
+test_expect_success 'showStat false showPatch false' '
+	test_stat_and_patch false false
+'
+
+test_expect_success 'showStat false showPatch true' '
+	test_stat_and_patch false true -p
+'
+
+test_expect_success 'showStat true showPatch unset' '
+	test_stat_and_patch true "<unset>" --stat
+'
+
+test_expect_success 'showStat true showPatch false' '
+	test_stat_and_patch true false --stat
+'
+
+test_expect_success 'showStat true showPatch true' '
+	test_stat_and_patch true true --stat -p
+'
+
+test_done
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#8 lore raw

PATCH v10 7/21 stash: mention options in `show` synopsis

In reply to Paul-Sebastian Ungureanu

Mention in the documentation, that show accepts any option known to git diff.

---
 Documentation/git-stash.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
Documentation/git-stash.txt +2 -2
index 7ef8c47911..e31ea7d303 100644
@@ -9,7 +9,7 @@ SYNOPSIS
 --------
 [verse]
 'git stash' list [<options>]
-'git stash' show [<stash>]
+'git stash' show [<options>] [<stash>]
 'git stash' drop [-q|--quiet] [<stash>]
 'git stash' ( pop | apply ) [--index] [-q|--quiet] [<stash>]
 'git stash' branch <branchname> [<stash>]
@@ -106,7 +106,7 @@ stash@{1}: On master: 9cc0589... Add git-stash
 The command takes options applicable to the 'git log'
 command to control what is shown and how. See linkgit:git-log[1].
 
-show [<stash>]::
+show [<options>] [<stash>]::
 
 	Show the changes recorded in the stash entry as a diff between the
 	stashed contents and the commit back when the stash entry was first
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#9 lore raw

PATCH v10 8/21 stash: convert apply to builtin

In reply to Paul-Sebastian Ungureanu

From: Joel Teichroeb <[email protected]>

Add a builtin helper for performing stash commands. Converting all at once proved hard to review, so starting with just apply lets conversion get started without the other commands being finished.

The helper is being implemented as a drop in replacement for stash so that when it is complete it can simply be renamed and the shell script deleted.

Delete the contents of the apply_stash shell function and replace it with a call to stash--helper apply until pop is also converted.

---
 .gitignore              |   1 +
 Makefile                |   1 +
 builtin.h               |   1 +
 builtin/stash--helper.c | 454 ++++++++++++++++++++++++++++++++++++++++
 git-stash.sh            |  78 +------
 git.c                   |   1 +
 6 files changed, 465 insertions(+), 71 deletions(-)
 create mode 100644 builtin/stash--helper.c
.gitignore +1 -0
index ffceea7d59..b59661cb88 100644
@@ -157,6 +157,7 @@
 /git-show-ref
 /git-stage
 /git-stash
+/git-stash--helper
 /git-status
 /git-stripspace
 /git-submodule
Makefile +1 -0
index d03df31c2a..f900c68e69 100644
@@ -1093,6 +1093,7 @@ BUILTIN_OBJS += builtin/shortlog.o
 BUILTIN_OBJS += builtin/show-branch.o
 BUILTIN_OBJS += builtin/show-index.o
 BUILTIN_OBJS += builtin/show-ref.o
+BUILTIN_OBJS += builtin/stash--helper.o
 BUILTIN_OBJS += builtin/stripspace.o
 BUILTIN_OBJS += builtin/submodule--helper.o
 BUILTIN_OBJS += builtin/symbolic-ref.o
builtin.h +1 -0
index 99206df4bd..317bc338f7 100644
@@ -223,6 +223,7 @@ extern int cmd_show(int argc, const char **argv, const char *prefix);
 extern int cmd_show_branch(int argc, const char **argv, const char *prefix);
 extern int cmd_show_index(int argc, const char **argv, const char *prefix);
 extern int cmd_status(int argc, const char **argv, const char *prefix);
+extern int cmd_stash__helper(int argc, const char **argv, const char *prefix);
 extern int cmd_stripspace(int argc, const char **argv, const char *prefix);
 extern int cmd_submodule__helper(int argc, const char **argv, const char *prefix);
 extern int cmd_symbolic_ref(int argc, const char **argv, const char *prefix);
builtin/stash--helper.c new file +454 -0

454 lines not on this page · raw message

git-stash.sh +7 -71

90 lines not on this page · raw message

git.c +1 -0
index c27c38738b..3c0e762d7d 100644
@@ -544,6 +544,7 @@ static struct cmd_struct commands[] = {
 	{ "show-index", cmd_show_index },
 	{ "show-ref", cmd_show_ref, RUN_SETUP },
 	{ "stage", cmd_add, RUN_SETUP | NEED_WORK_TREE },
+	{ "stash--helper", cmd_stash__helper, RUN_SETUP | NEED_WORK_TREE },
 	{ "status", cmd_status, RUN_SETUP | NEED_WORK_TREE },
 	{ "stripspace", cmd_stripspace },
 	{ "submodule--helper", cmd_submodule__helper, RUN_SETUP | SUPPORT_SUPER_PREFIX | NO_PARSEOPT },
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#10 lore raw

Re: [PATCH v10 08/21] stash: convert apply to builtin

Hi Paul,

builtin/stash--helper.c line 65

Quoted 9 lines · Paul-Sebastian Ungureanu
builtin/stash--helper.c new file +9 -0
+static void assert_stash_like(struct stash_info *info, const char *revision)
+{
+	if (get_oidf(&info->b_commit, "%s^1", revision) ||
+	    get_oidf(&info->w_tree, "%s:", revision) ||
+	    get_oidf(&info->b_tree, "%s^1:", revision) ||
+	    get_oidf(&info->i_tree, "%s^2:", revision)) {
+		error(_("'%s' is not a stash-like commit"), revision);
+		free_stash_info(info);
+		exit(128);

Thomas had mentioned earlier that this should probably be a die() (and that the free_stash_info() should simply be dropped), see
https://public-inbox.org/git/[email protected]/

Quoted 8 lines
builtin/stash--helper.c new file +8 -0
+	}
+}
+
+static int get_stash_info(struct stash_info *info, int argc, const char **argv)
+{
+	int ret;
+	char *end_of_rev;
+	char *expanded_ref;

builtin/stash--helper.c line 83

Quoted 10 lines
builtin/stash--helper.c new file +10 -0
+	const char *revision;
+	const char *commit = NULL;
+	struct object_id dummy;
+	struct strbuf symbolic = STRBUF_INIT;
+
+	if (argc > 1) {
+		int i;
+		struct strbuf refs_msg = STRBUF_INIT;
+		for (i = 0; i < argc; i++)
+			strbuf_addf(&refs_msg, " '%s'", argv[i]);

Thomas had also mentioned that this should be a strbuf_join_argv() call now.

Maybe v10 is an accidental re-send of v9?

Ciao,
Dscho

Quoted 483 lines
builtin/stash--helper.c new file +371 -0
+
+		fprintf_ln(stderr, _("Too many revisions specified:%s"),
+			   refs_msg.buf);
+		strbuf_release(&refs_msg);
+
+		return -1;
+	}
+
+	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);
+	}
+
+	revision = info->revision.buf;
+
+	if (get_oid(revision, &info->w_commit)) {
+		error(_("%s is not a valid reference"), revision);
+		free_stash_info(info);
+		return -1;
+	}
+
+	assert_stash_like(info, revision);
+
+	info->has_u = !get_oidf(&info->u_tree, "%s^3:", revision);
+
+	end_of_rev = strchrnul(revision, '@');
+	strbuf_add(&symbolic, revision, end_of_rev - revision);
+
+	ret = dwim_ref(symbolic.buf, symbolic.len, &dummy, &expanded_ref);
+	strbuf_release(&symbolic);
+	switch (ret) {
+	case 0: /* Not found, but valid ref */
+		info->is_stash_ref = 0;
+		break;
+	case 1:
+		info->is_stash_ref = !strcmp(expanded_ref, ref_stash);
+		break;
+	default: /* Invalid or ambiguous */
+		free_stash_info(info);
+	}
+
+	free(expanded_ref);
+	return !(ret == 0 || ret == 1);
+}
+
+static int reset_tree(struct object_id *i_tree, int update, int reset)
+{
+	int nr_trees = 1;
+	struct unpack_trees_options opts;
+	struct tree_desc t[MAX_UNPACK_TREES];
+	struct tree *tree;
+	struct lock_file lock_file = LOCK_INIT;
+
+	read_cache_preload(NULL);
+	if (refresh_cache(REFRESH_QUIET))
+		return -1;
+
+	hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
+
+	memset(&opts, 0, sizeof(opts));
+
+	tree = parse_tree_indirect(i_tree);
+	if (parse_tree(tree))
+		return -1;
+
+	init_tree_desc(t, tree->buffer, tree->size);
+
+	opts.head_idx = 1;
+	opts.src_index = &the_index;
+	opts.dst_index = &the_index;
+	opts.merge = 1;
+	opts.reset = reset;
+	opts.update = update;
+	opts.fn = oneway_merge;
+
+	if (unpack_trees(nr_trees, t, &opts))
+		return -1;
+
+	if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
+		return error(_("unable to write new index file"));
+
+	return 0;
+}
+
+static int diff_tree_binary(struct strbuf *out, struct object_id *w_commit)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+	const char *w_commit_hex = oid_to_hex(w_commit);
+
+	/*
+	 * Diff-tree would not be very hard to replace with a native function,
+	 * however it should be done together with apply_cached.
+	 */
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "diff-tree", "--binary", NULL);
+	argv_array_pushf(&cp.args, "%s^2^..%s^2", w_commit_hex, w_commit_hex);
+
+	return pipe_command(&cp, NULL, 0, out, 0, NULL, 0);
+}
+
+static int apply_cached(struct strbuf *out)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	/*
+	 * Apply currently only reads either from stdin or a file, thus
+	 * apply_all_patches would have to be updated to optionally take a
+	 * buffer.
+	 */
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "apply", "--cached", NULL);
+	return pipe_command(&cp, out->buf, out->len, NULL, 0, NULL, 0);
+}
+
+static int reset_head(void)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	/*
+	 * Reset is overall quite simple, however there is no current public
+	 * API for resetting.
+	 */
+	cp.git_cmd = 1;
+	argv_array_push(&cp.args, "reset");
+
+	return run_command(&cp);
+}
+
+static int get_newly_staged(struct strbuf *out, struct object_id *c_tree)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+	const char *c_tree_hex = oid_to_hex(c_tree);
+
+	/*
+	 * diff-index is very similar to diff-tree above, and should be
+	 * converted together with update_index.
+	 */
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "diff-index", "--cached", "--name-only",
+			 "--diff-filter=A", NULL);
+	argv_array_push(&cp.args, c_tree_hex);
+	return pipe_command(&cp, NULL, 0, out, 0, NULL, 0);
+}
+
+static int update_index(struct strbuf *out)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	/*
+	 * Update-index is very complicated and may need to have a public
+	 * function exposed in order to remove this forking.
+	 */
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "update-index", "--add", "--stdin", NULL);
+	return pipe_command(&cp, out->buf, out->len, NULL, 0, NULL, 0);
+}
+
+static int restore_untracked(struct object_id *u_tree)
+{
+	int res;
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	/*
+	 * We need to run restore files from a given index, but without
+	 * affecting the current index, so we use GIT_INDEX_FILE with
+	 * run_command to fork processes that will not interfere.
+	 */
+	cp.git_cmd = 1;
+	argv_array_push(&cp.args, "read-tree");
+	argv_array_push(&cp.args, oid_to_hex(u_tree));
+	argv_array_pushf(&cp.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+	if (run_command(&cp)) {
+		remove_path(stash_index_path.buf);
+		return -1;
+	}
+
+	child_process_init(&cp);
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "checkout-index", "--all", NULL);
+	argv_array_pushf(&cp.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+
+	res = run_command(&cp);
+	remove_path(stash_index_path.buf);
+	return res;
+}
+
+static int do_apply_stash(const char *prefix, struct stash_info *info,
+			  int index, int quiet)
+{
+	int ret;
+	int has_index = index;
+	struct merge_options o;
+	struct object_id c_tree;
+	struct object_id index_tree;
+	struct commit *result;
+	const struct object_id *bases[1];
+
+	read_cache_preload(NULL);
+	if (refresh_cache(REFRESH_QUIET))
+		return -1;
+
+	if (write_cache_as_tree(&c_tree, 0, NULL) || reset_tree(&c_tree, 0, 0))
+		return error(_("cannot apply a stash in the middle of a merge"));
+
+	if (index) {
+		if (!oidcmp(&info->b_tree, &info->i_tree) ||
+		    !oidcmp(&c_tree, &info->i_tree)) {
+			has_index = 0;
+		} else {
+			struct strbuf out = STRBUF_INIT;
+
+			if (diff_tree_binary(&out, &info->w_commit)) {
+				strbuf_release(&out);
+				return error(_("Could not generate diff %s^!."),
+					     oid_to_hex(&info->w_commit));
+			}
+
+			ret = apply_cached(&out);
+			strbuf_release(&out);
+			if (ret)
+				return error(_("Conflicts in index."
+					       "Try without --index."));
+
+			discard_cache();
+			read_cache();
+			if (write_cache_as_tree(&index_tree, 0, NULL))
+				return error(_("Could not save index tree"));
+
+			reset_head();
+		}
+	}
+
+	if (info->has_u && restore_untracked(&info->u_tree))
+		return error(_("could not restore untracked files from stash"));
+
+	init_merge_options(&o);
+
+	o.branch1 = "Updated upstream";
+	o.branch2 = "Stashed changes";
+
+	if (!oidcmp(&info->b_tree, &c_tree))
+		o.branch1 = "Version stash was based on";
+
+	if (quiet)
+		o.verbosity = 0;
+
+	if (o.verbosity >= 3)
+		printf_ln(_("Merging %s with %s"), o.branch1, o.branch2);
+
+	bases[0] = &info->b_tree;
+
+	ret = merge_recursive_generic(&o, &c_tree, &info->w_tree, 1, bases,
+				      &result);
+	if (ret) {
+		rerere(0);
+
+		if (index)
+			fprintf_ln(stderr, _("Index was not unstashed."));
+
+		return ret;
+	}
+
+	if (has_index) {
+		if (reset_tree(&index_tree, 0, 0))
+			return -1;
+	} else {
+		struct strbuf out = STRBUF_INIT;
+
+		if (get_newly_staged(&out, &c_tree)) {
+			strbuf_release(&out);
+			return -1;
+		}
+
+		if (reset_tree(&c_tree, 0, 1)) {
+			strbuf_release(&out);
+			return -1;
+		}
+
+		ret = update_index(&out);
+		strbuf_release(&out);
+		if (ret)
+			return -1;
+
+		discard_cache();
+	}
+
+	if (quiet) {
+		if (refresh_cache(REFRESH_QUIET))
+			warning("could not refresh index");
+	} else {
+		struct child_process cp = CHILD_PROCESS_INIT;
+
+		/*
+		 * Status is quite simple and could be replaced with calls to
+		 * wt_status in the future, but it adds complexities which may
+		 * require more tests.
+		 */
+		cp.git_cmd = 1;
+		cp.dir = prefix;
+		argv_array_push(&cp.args, "status");
+		run_command(&cp);
+	}
+
+	return 0;
+}
+
+static int apply_stash(int argc, const char **argv, const char *prefix)
+{
+	int ret;
+	int quiet = 0;
+	int index = 0;
+	struct stash_info info;
+	struct option options[] = {
+		OPT__QUIET(&quiet, N_("be quiet, only report errors")),
+		OPT_BOOL(0, "index", &index,
+			 N_("attempt to recreate the index")),
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_apply_usage, 0);
+
+	if (get_stash_info(&info, argc, argv))
+		return -1;
+
+	ret = do_apply_stash(prefix, &info, index, quiet);
+	free_stash_info(&info);
+	return ret;
+}
+
+int cmd_stash__helper(int argc, const char **argv, const char *prefix)
+{
+	pid_t pid = getpid();
+	const char *index_file;
+
+	struct option options[] = {
+		OPT_END()
+	};
+
+	git_config(git_default_config, NULL);
+
+	argc = parse_options(argc, argv, prefix, options, git_stash_helper_usage,
+			     PARSE_OPT_KEEP_UNKNOWN | PARSE_OPT_KEEP_DASHDASH);
+
+	index_file = get_index_file();
+	strbuf_addf(&stash_index_path, "%s.stash.%" PRIuMAX, index_file,
+		    (uintmax_t)pid);
+
+	if (argc < 1)
+		usage_with_options(git_stash_helper_usage, options);
+	if (!strcmp(argv[0], "apply"))
+		return !!apply_stash(argc, argv, prefix);
+
+	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
+		      git_stash_helper_usage, options);
+}
git-stash.sh +7 -71
index 94793c1a91..809b1c2d1d 100755
@@ -566,76 +566,11 @@ assert_stash_ref() {
 }
 
 apply_stash () {
-
-	assert_stash_like "$@"
-
-	git update-index -q --refresh || die "$(gettext "unable to refresh index")"
-
-	# current index state
-	c_tree=$(git write-tree) ||
-		die "$(gettext "Cannot apply a stash in the middle of a merge")"
-
-	unstashed_index_tree=
-	if test -n "$INDEX_OPTION" && test "$b_tree" != "$i_tree" &&
-			test "$c_tree" != "$i_tree"
-	then
-		git diff-tree --binary $s^2^..$s^2 | git apply --cached
-		test $? -ne 0 &&
-			die "$(gettext "Conflicts in index. Try without --index.")"
-		unstashed_index_tree=$(git write-tree) ||
-			die "$(gettext "Could not save index tree")"
-		git reset
-	fi
-
-	if test -n "$u_tree"
-	then
-		GIT_INDEX_FILE="$TMPindex" git read-tree "$u_tree" &&
-		GIT_INDEX_FILE="$TMPindex" git checkout-index --all &&
-		rm -f "$TMPindex" ||
-		die "$(gettext "Could not restore untracked files from stash entry")"
-	fi
-
-	eval "
-		GITHEAD_$w_tree='Stashed changes' &&
-		GITHEAD_$c_tree='Updated upstream' &&
-		GITHEAD_$b_tree='Version stash was based on' &&
-		export GITHEAD_$w_tree GITHEAD_$c_tree GITHEAD_$b_tree
-	"
-
-	if test -n "$GIT_QUIET"
-	then
-		GIT_MERGE_VERBOSITY=0 && export GIT_MERGE_VERBOSITY
-	fi
-	if git merge-recursive $b_tree -- $c_tree $w_tree
-	then
-		# No conflict
-		if test -n "$unstashed_index_tree"
-		then
-			git read-tree "$unstashed_index_tree"
-		else
-			a="$TMP-added" &&
-			git diff-index --cached --name-only --diff-filter=A $c_tree >"$a" &&
-			git read-tree --reset $c_tree &&
-			git update-index --add --stdin <"$a" ||
-				die "$(gettext "Cannot unstage modified files")"
-			rm -f "$a"
-		fi
-		squelch=
-		if test -n "$GIT_QUIET"
-		then
-			squelch='>/dev/null 2>&1'
-		fi
-		(cd "$START_DIR" && eval "git status $squelch") || :
-	else
-		# Merge conflict; keep the exit status from merge-recursive
-		status=$?
-		git rerere
-		if test -n "$INDEX_OPTION"
-		then
-			gettextln "Index was not unstashed." >&2
-		fi
-		exit $status
-	fi
+	cd "$START_DIR"
+	git stash--helper apply "$@"
+	res=$?
+	cd_to_toplevel
+	return $res
 }
 
 pop_stash() {
@@ -713,7 +648,8 @@ push)
 	;;
 apply)
 	shift
-	apply_stash "$@"
+	cd "$START_DIR"
+	git stash--helper apply "$@"
 	;;
 clear)
 	shift
git.c +1 -0
index c27c38738b..3c0e762d7d 100644
@@ -544,6 +544,7 @@ static struct cmd_struct commands[] = {
 	{ "show-index", cmd_show_index },
 	{ "show-ref", cmd_show_ref, RUN_SETUP },
 	{ "stage", cmd_add, RUN_SETUP | NEED_WORK_TREE },
+	{ "stash--helper", cmd_stash__helper, RUN_SETUP | NEED_WORK_TREE },
 	{ "status", cmd_status, RUN_SETUP | NEED_WORK_TREE },
 	{ "stripspace", cmd_stripspace },
 	{ "submodule--helper", cmd_submodule__helper, RUN_SETUP | SUPPORT_SUPER_PREFIX | NO_PARSEOPT },
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#11 lore raw

Re: [PATCH v10 08/21] stash: convert apply to builtin

Quoted 4 lines · Johannes Schindelin

Hi Paul,

On Mon, 15 Oct 2018, Paul-Sebastian Ungureanu wrote:

Quoted 13 lines

builtin/stash--helper.c line 65

Quoted 9 lines
builtin/stash--helper.c new file +9 -0
+static void assert_stash_like(struct stash_info *info, const char *revision)
+{
+	if (get_oidf(&info->b_commit, "%s^1", revision) ||
+	    get_oidf(&info->w_tree, "%s:", revision) ||
+	    get_oidf(&info->b_tree, "%s^1:", revision) ||
+	    get_oidf(&info->i_tree, "%s^2:", revision)) {
+		error(_("'%s' is not a stash-like commit"), revision);
+		free_stash_info(info);
+		exit(128);

Thomas had mentioned earlier that this should probably be a die() (and that the free_stash_info() should simply be dropped), see
https://public-inbox.org/git/[email protected]/

I think the way this is now is fine by me. Not sure how much we care about freeing 'info' or not (do we care about leaks when we 'die()' anyway?), but this is done in the right order now, so we don't print garbage in the error message anymore, and I'm happy with either this or replacing all this with 'die()'.

Quoted 13 lines
Quoted 13 lines
builtin/stash--helper.c new file +13 -0
+	}
+}
+
+static int get_stash_info(struct stash_info *info, int argc, const char **argv)
+{
+	int ret;
+	char *end_of_rev;
+	char *expanded_ref;
+	const char *revision;
+	const char *commit = NULL;
+	struct object_id dummy;
+	struct strbuf symbolic = STRBUF_INIT;
+
Quoted 8 lines

builtin/stash--helper.c line 83

Quoted 5 lines
builtin/stash--helper.c new file +5 -0
+	if (argc > 1) {
+		int i;
+		struct strbuf refs_msg = STRBUF_INIT;
+		for (i = 0; i < argc; i++)
+			strbuf_addf(&refs_msg, " '%s'", argv[i]);

Thomas had also mentioned that this should be a strbuf_join_argv() call now.

Re-reading this we quote the individual args here, which is not possible with 'strbuf_join_argv()', which I failed to notice when reading this the other time. We don't currently quote them, but I think the quoting may actually be useful.

It would however have been nice if the reason why the suggestion was rejected would have been written down as a reply to my original review, to avoid misunderstandings like this :)

Quoted 488 lines

Maybe v10 is an accidental re-send of v9?

Ciao,
Dscho

Quoted 483 lines
builtin/stash--helper.c new file +371 -0
+
+		fprintf_ln(stderr, _("Too many revisions specified:%s"),
+			   refs_msg.buf);
+		strbuf_release(&refs_msg);
+
+		return -1;
+	}
+
+	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);
+	}
+
+	revision = info->revision.buf;
+
+	if (get_oid(revision, &info->w_commit)) {
+		error(_("%s is not a valid reference"), revision);
+		free_stash_info(info);
+		return -1;
+	}
+
+	assert_stash_like(info, revision);
+
+	info->has_u = !get_oidf(&info->u_tree, "%s^3:", revision);
+
+	end_of_rev = strchrnul(revision, '@');
+	strbuf_add(&symbolic, revision, end_of_rev - revision);
+
+	ret = dwim_ref(symbolic.buf, symbolic.len, &dummy, &expanded_ref);
+	strbuf_release(&symbolic);
+	switch (ret) {
+	case 0: /* Not found, but valid ref */
+		info->is_stash_ref = 0;
+		break;
+	case 1:
+		info->is_stash_ref = !strcmp(expanded_ref, ref_stash);
+		break;
+	default: /* Invalid or ambiguous */
+		free_stash_info(info);
+	}
+
+	free(expanded_ref);
+	return !(ret == 0 || ret == 1);
+}
+
+static int reset_tree(struct object_id *i_tree, int update, int reset)
+{
+	int nr_trees = 1;
+	struct unpack_trees_options opts;
+	struct tree_desc t[MAX_UNPACK_TREES];
+	struct tree *tree;
+	struct lock_file lock_file = LOCK_INIT;
+
+	read_cache_preload(NULL);
+	if (refresh_cache(REFRESH_QUIET))
+		return -1;
+
+	hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
+
+	memset(&opts, 0, sizeof(opts));
+
+	tree = parse_tree_indirect(i_tree);
+	if (parse_tree(tree))
+		return -1;
+
+	init_tree_desc(t, tree->buffer, tree->size);
+
+	opts.head_idx = 1;
+	opts.src_index = &the_index;
+	opts.dst_index = &the_index;
+	opts.merge = 1;
+	opts.reset = reset;
+	opts.update = update;
+	opts.fn = oneway_merge;
+
+	if (unpack_trees(nr_trees, t, &opts))
+		return -1;
+
+	if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
+		return error(_("unable to write new index file"));
+
+	return 0;
+}
+
+static int diff_tree_binary(struct strbuf *out, struct object_id *w_commit)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+	const char *w_commit_hex = oid_to_hex(w_commit);
+
+	/*
+	 * Diff-tree would not be very hard to replace with a native function,
+	 * however it should be done together with apply_cached.
+	 */
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "diff-tree", "--binary", NULL);
+	argv_array_pushf(&cp.args, "%s^2^..%s^2", w_commit_hex, w_commit_hex);
+
+	return pipe_command(&cp, NULL, 0, out, 0, NULL, 0);
+}
+
+static int apply_cached(struct strbuf *out)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	/*
+	 * Apply currently only reads either from stdin or a file, thus
+	 * apply_all_patches would have to be updated to optionally take a
+	 * buffer.
+	 */
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "apply", "--cached", NULL);
+	return pipe_command(&cp, out->buf, out->len, NULL, 0, NULL, 0);
+}
+
+static int reset_head(void)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	/*
+	 * Reset is overall quite simple, however there is no current public
+	 * API for resetting.
+	 */
+	cp.git_cmd = 1;
+	argv_array_push(&cp.args, "reset");
+
+	return run_command(&cp);
+}
+
+static int get_newly_staged(struct strbuf *out, struct object_id *c_tree)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+	const char *c_tree_hex = oid_to_hex(c_tree);
+
+	/*
+	 * diff-index is very similar to diff-tree above, and should be
+	 * converted together with update_index.
+	 */
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "diff-index", "--cached", "--name-only",
+			 "--diff-filter=A", NULL);
+	argv_array_push(&cp.args, c_tree_hex);
+	return pipe_command(&cp, NULL, 0, out, 0, NULL, 0);
+}
+
+static int update_index(struct strbuf *out)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	/*
+	 * Update-index is very complicated and may need to have a public
+	 * function exposed in order to remove this forking.
+	 */
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "update-index", "--add", "--stdin", NULL);
+	return pipe_command(&cp, out->buf, out->len, NULL, 0, NULL, 0);
+}
+
+static int restore_untracked(struct object_id *u_tree)
+{
+	int res;
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	/*
+	 * We need to run restore files from a given index, but without
+	 * affecting the current index, so we use GIT_INDEX_FILE with
+	 * run_command to fork processes that will not interfere.
+	 */
+	cp.git_cmd = 1;
+	argv_array_push(&cp.args, "read-tree");
+	argv_array_push(&cp.args, oid_to_hex(u_tree));
+	argv_array_pushf(&cp.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+	if (run_command(&cp)) {
+		remove_path(stash_index_path.buf);
+		return -1;
+	}
+
+	child_process_init(&cp);
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "checkout-index", "--all", NULL);
+	argv_array_pushf(&cp.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+
+	res = run_command(&cp);
+	remove_path(stash_index_path.buf);
+	return res;
+}
+
+static int do_apply_stash(const char *prefix, struct stash_info *info,
+			  int index, int quiet)
+{
+	int ret;
+	int has_index = index;
+	struct merge_options o;
+	struct object_id c_tree;
+	struct object_id index_tree;
+	struct commit *result;
+	const struct object_id *bases[1];
+
+	read_cache_preload(NULL);
+	if (refresh_cache(REFRESH_QUIET))
+		return -1;
+
+	if (write_cache_as_tree(&c_tree, 0, NULL) || reset_tree(&c_tree, 0, 0))
+		return error(_("cannot apply a stash in the middle of a merge"));
+
+	if (index) {
+		if (!oidcmp(&info->b_tree, &info->i_tree) ||
+		    !oidcmp(&c_tree, &info->i_tree)) {
+			has_index = 0;
+		} else {
+			struct strbuf out = STRBUF_INIT;
+
+			if (diff_tree_binary(&out, &info->w_commit)) {
+				strbuf_release(&out);
+				return error(_("Could not generate diff %s^!."),
+					     oid_to_hex(&info->w_commit));
+			}
+
+			ret = apply_cached(&out);
+			strbuf_release(&out);
+			if (ret)
+				return error(_("Conflicts in index."
+					       "Try without --index."));
+
+			discard_cache();
+			read_cache();
+			if (write_cache_as_tree(&index_tree, 0, NULL))
+				return error(_("Could not save index tree"));
+
+			reset_head();
+		}
+	}
+
+	if (info->has_u && restore_untracked(&info->u_tree))
+		return error(_("could not restore untracked files from stash"));
+
+	init_merge_options(&o);
+
+	o.branch1 = "Updated upstream";
+	o.branch2 = "Stashed changes";
+
+	if (!oidcmp(&info->b_tree, &c_tree))
+		o.branch1 = "Version stash was based on";
+
+	if (quiet)
+		o.verbosity = 0;
+
+	if (o.verbosity >= 3)
+		printf_ln(_("Merging %s with %s"), o.branch1, o.branch2);
+
+	bases[0] = &info->b_tree;
+
+	ret = merge_recursive_generic(&o, &c_tree, &info->w_tree, 1, bases,
+				      &result);
+	if (ret) {
+		rerere(0);
+
+		if (index)
+			fprintf_ln(stderr, _("Index was not unstashed."));
+
+		return ret;
+	}
+
+	if (has_index) {
+		if (reset_tree(&index_tree, 0, 0))
+			return -1;
+	} else {
+		struct strbuf out = STRBUF_INIT;
+
+		if (get_newly_staged(&out, &c_tree)) {
+			strbuf_release(&out);
+			return -1;
+		}
+
+		if (reset_tree(&c_tree, 0, 1)) {
+			strbuf_release(&out);
+			return -1;
+		}
+
+		ret = update_index(&out);
+		strbuf_release(&out);
+		if (ret)
+			return -1;
+
+		discard_cache();
+	}
+
+	if (quiet) {
+		if (refresh_cache(REFRESH_QUIET))
+			warning("could not refresh index");
+	} else {
+		struct child_process cp = CHILD_PROCESS_INIT;
+
+		/*
+		 * Status is quite simple and could be replaced with calls to
+		 * wt_status in the future, but it adds complexities which may
+		 * require more tests.
+		 */
+		cp.git_cmd = 1;
+		cp.dir = prefix;
+		argv_array_push(&cp.args, "status");
+		run_command(&cp);
+	}
+
+	return 0;
+}
+
+static int apply_stash(int argc, const char **argv, const char *prefix)
+{
+	int ret;
+	int quiet = 0;
+	int index = 0;
+	struct stash_info info;
+	struct option options[] = {
+		OPT__QUIET(&quiet, N_("be quiet, only report errors")),
+		OPT_BOOL(0, "index", &index,
+			 N_("attempt to recreate the index")),
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_apply_usage, 0);
+
+	if (get_stash_info(&info, argc, argv))
+		return -1;
+
+	ret = do_apply_stash(prefix, &info, index, quiet);
+	free_stash_info(&info);
+	return ret;
+}
+
+int cmd_stash__helper(int argc, const char **argv, const char *prefix)
+{
+	pid_t pid = getpid();
+	const char *index_file;
+
+	struct option options[] = {
+		OPT_END()
+	};
+
+	git_config(git_default_config, NULL);
+
+	argc = parse_options(argc, argv, prefix, options, git_stash_helper_usage,
+			     PARSE_OPT_KEEP_UNKNOWN | PARSE_OPT_KEEP_DASHDASH);
+
+	index_file = get_index_file();
+	strbuf_addf(&stash_index_path, "%s.stash.%" PRIuMAX, index_file,
+		    (uintmax_t)pid);
+
+	if (argc < 1)
+		usage_with_options(git_stash_helper_usage, options);
+	if (!strcmp(argv[0], "apply"))
+		return !!apply_stash(argc, argv, prefix);
+
+	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
+		      git_stash_helper_usage, options);
+}
git-stash.sh +7 -71
index 94793c1a91..809b1c2d1d 100755
@@ -566,76 +566,11 @@ assert_stash_ref() {
 }
 
 apply_stash () {
-
-	assert_stash_like "$@"
-
-	git update-index -q --refresh || die "$(gettext "unable to refresh index")"
-
-	# current index state
-	c_tree=$(git write-tree) ||
-		die "$(gettext "Cannot apply a stash in the middle of a merge")"
-
-	unstashed_index_tree=
-	if test -n "$INDEX_OPTION" && test "$b_tree" != "$i_tree" &&
-			test "$c_tree" != "$i_tree"
-	then
-		git diff-tree --binary $s^2^..$s^2 | git apply --cached
-		test $? -ne 0 &&
-			die "$(gettext "Conflicts in index. Try without --index.")"
-		unstashed_index_tree=$(git write-tree) ||
-			die "$(gettext "Could not save index tree")"
-		git reset
-	fi
-
-	if test -n "$u_tree"
-	then
-		GIT_INDEX_FILE="$TMPindex" git read-tree "$u_tree" &&
-		GIT_INDEX_FILE="$TMPindex" git checkout-index --all &&
-		rm -f "$TMPindex" ||
-		die "$(gettext "Could not restore untracked files from stash entry")"
-	fi
-
-	eval "
-		GITHEAD_$w_tree='Stashed changes' &&
-		GITHEAD_$c_tree='Updated upstream' &&
-		GITHEAD_$b_tree='Version stash was based on' &&
-		export GITHEAD_$w_tree GITHEAD_$c_tree GITHEAD_$b_tree
-	"
-
-	if test -n "$GIT_QUIET"
-	then
-		GIT_MERGE_VERBOSITY=0 && export GIT_MERGE_VERBOSITY
-	fi
-	if git merge-recursive $b_tree -- $c_tree $w_tree
-	then
-		# No conflict
-		if test -n "$unstashed_index_tree"
-		then
-			git read-tree "$unstashed_index_tree"
-		else
-			a="$TMP-added" &&
-			git diff-index --cached --name-only --diff-filter=A $c_tree >"$a" &&
-			git read-tree --reset $c_tree &&
-			git update-index --add --stdin <"$a" ||
-				die "$(gettext "Cannot unstage modified files")"
-			rm -f "$a"
-		fi
-		squelch=
-		if test -n "$GIT_QUIET"
-		then
-			squelch='>/dev/null 2>&1'
-		fi
-		(cd "$START_DIR" && eval "git status $squelch") || :
-	else
-		# Merge conflict; keep the exit status from merge-recursive
-		status=$?
-		git rerere
-		if test -n "$INDEX_OPTION"
-		then
-			gettextln "Index was not unstashed." >&2
-		fi
-		exit $status
-	fi
+	cd "$START_DIR"
+	git stash--helper apply "$@"
+	res=$?
+	cd_to_toplevel
+	return $res
 }
 
 pop_stash() {
@@ -713,7 +648,8 @@ push)
 	;;
 apply)
 	shift
-	apply_stash "$@"
+	cd "$START_DIR"
+	git stash--helper apply "$@"
 	;;
 clear)
 	shift
git.c +1 -0
index c27c38738b..3c0e762d7d 100644
@@ -544,6 +544,7 @@ static struct cmd_struct commands[] = {
 	{ "show-index", cmd_show_index },
 	{ "show-ref", cmd_show_ref, RUN_SETUP },
 	{ "stage", cmd_add, RUN_SETUP | NEED_WORK_TREE },
+	{ "stash--helper", cmd_stash__helper, RUN_SETUP | NEED_WORK_TREE },
 	{ "status", cmd_status, RUN_SETUP | NEED_WORK_TREE },
 	{ "stripspace", cmd_stripspace },
 	{ "submodule--helper", cmd_submodule__helper, RUN_SETUP | SUPPORT_SUPER_PREFIX | NO_PARSEOPT },
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#12 lore raw

PATCH v10 9/21 stash: convert drop and clear to builtin

In reply to Paul-Sebastian Ungureanu

From: Joel Teichroeb <[email protected]>

Add the drop and clear commands to the builtin helper. These two are each simple, but are being added together as they are quite related.

We have to unfortunately keep the drop and clear functions in the shell script as functions are called with parameters internally that are not valid when the commands are called externally. Once pop is converted they can both be removed.

---
 builtin/stash--helper.c | 117 ++++++++++++++++++++++++++++++++++++++++
 git-stash.sh            |   4 +-
 2 files changed, 119 insertions(+), 2 deletions(-)
builtin/stash--helper.c +117 -0
index c43e0aacbb..aff6cda4c9 100644
@@ -12,7 +12,14 @@
 #include "rerere.h"
 
 static const char * const git_stash_helper_usage[] = {
+	N_("git stash--helper drop [-q|--quiet] [<stash>]"),
 	N_("git stash--helper apply [--index] [-q|--quiet] [<stash>]"),
+	N_("git stash--helper clear"),
+	NULL
+};
+
+static const char * const git_stash_helper_drop_usage[] = {
+	N_("git stash--helper drop [-q|--quiet] [<stash>]"),
 	NULL
 };
 
@@ -21,6 +28,11 @@ static const char * const git_stash_helper_apply_usage[] = {
 	NULL
 };
 
+static const char * const git_stash_helper_clear_usage[] = {
+	N_("git stash--helper clear"),
+	NULL
+};
+
 static const char *ref_stash = "refs/stash";
 static struct strbuf stash_index_path = STRBUF_INIT;
 
@@ -139,6 +151,32 @@ static int get_stash_info(struct stash_info *info, int argc, const char **argv)
 	return !(ret == 0 || ret == 1);
 }
 
+static int do_clear_stash(void)
+{
+	struct object_id obj;
+	if (get_oid(ref_stash, &obj))
+		return 0;
+
+	return delete_ref(NULL, ref_stash, &obj, 0);
+}
+
+static int clear_stash(int argc, const char **argv, const char *prefix)
+{
+	struct option options[] = {
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_clear_usage,
+			     PARSE_OPT_STOP_AT_NON_OPTION);
+
+	if (argc)
+		return error(_("git stash clear with parameters is "
+			       "unimplemented"));
+
+	return do_clear_stash();
+}
+
 static int reset_tree(struct object_id *i_tree, int update, int reset)
 {
 	int nr_trees = 1;
@@ -426,6 +464,81 @@ static int apply_stash(int argc, const char **argv, const char *prefix)
 	return ret;
 }
 
+static int do_drop_stash(const char *prefix, struct stash_info *info, int quiet)
+{
+	int ret;
+	struct child_process cp_reflog = CHILD_PROCESS_INIT;
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	/*
+	 * reflog does not provide a simple function for deleting refs. One will
+	 * need to be added to avoid implementing too much reflog code here
+	 */
+
+	cp_reflog.git_cmd = 1;
+	argv_array_pushl(&cp_reflog.args, "reflog", "delete", "--updateref",
+			 "--rewrite", NULL);
+	argv_array_push(&cp_reflog.args, info->revision.buf);
+	ret = run_command(&cp_reflog);
+	if (!ret) {
+		if (!quiet)
+			printf_ln(_("Dropped %s (%s)"), info->revision.buf,
+				  oid_to_hex(&info->w_commit));
+	} else {
+		return error(_("%s: Could not drop stash entry"),
+			     info->revision.buf);
+	}
+
+	/*
+	 * This could easily be replaced by get_oid, but currently it will throw
+	 * a fatal error when a reflog is empty, which we can not recover from.
+	 */
+	cp.git_cmd = 1;
+	/* Even though --quiet is specified, rev-parse still outputs the hash */
+	cp.no_stdout = 1;
+	argv_array_pushl(&cp.args, "rev-parse", "--verify", "--quiet", NULL);
+	argv_array_pushf(&cp.args, "%s@{0}", ref_stash);
+	ret = run_command(&cp);
+
+	/* do_clear_stash if we just dropped the last stash entry */
+	if (ret)
+		do_clear_stash();
+
+	return 0;
+}
+
+static void assert_stash_ref(struct stash_info *info)
+{
+	if (!info->is_stash_ref) {
+		free_stash_info(info);
+		error(_("'%s' is not a stash reference"), info->revision.buf);
+		exit(128);
+	}
+}
+
+static int drop_stash(int argc, const char **argv, const char *prefix)
+{
+	int ret;
+	int quiet = 0;
+	struct stash_info info;
+	struct option options[] = {
+		OPT__QUIET(&quiet, N_("be quiet, only report errors")),
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_drop_usage, 0);
+
+	if (get_stash_info(&info, argc, argv))
+		return -1;
+
+	assert_stash_ref(&info);
+
+	ret = do_drop_stash(prefix, &info, quiet);
+	free_stash_info(&info);
+	return ret;
+}
+
 int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 {
 	pid_t pid = getpid();
@@ -448,6 +561,10 @@ int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 		usage_with_options(git_stash_helper_usage, options);
 	if (!strcmp(argv[0], "apply"))
 		return !!apply_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "clear"))
+		return !!clear_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "drop"))
+		return !!drop_stash(argc, argv, prefix);
 
 	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
 		      git_stash_helper_usage, options);
git-stash.sh +2 -2
index 809b1c2d1d..a99d5dc9e5 100755
@@ -653,7 +653,7 @@ apply)
 	;;
 clear)
 	shift
-	clear_stash "$@"
+	git stash--helper clear "$@"
 	;;
 create)
 	shift
@@ -665,7 +665,7 @@ store)
 	;;
 drop)
 	shift
-	drop_stash "$@"
+	git stash--helper drop "$@"
 	;;
 pop)
 	shift
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#13 lore raw

PATCH v10 10/21 stash: convert branch to builtin

In reply to Paul-Sebastian Ungureanu

From: Joel Teichroeb <[email protected]>

Add stash branch to the helper and delete the apply_to_branch function from the shell script.

Checkout does not currently provide a function for checking out a branch as cmd_checkout does a large amount of sanity checks first that we require here.

---
 builtin/stash--helper.c | 46 +++++++++++++++++++++++++++++++++++++++++
 git-stash.sh            | 17 ++-------------
 2 files changed, 48 insertions(+), 15 deletions(-)
builtin/stash--helper.c +46 -0
index aff6cda4c9..c41aad7036 100644
@@ -14,6 +14,7 @@
 static const char * const git_stash_helper_usage[] = {
 	N_("git stash--helper drop [-q|--quiet] [<stash>]"),
 	N_("git stash--helper apply [--index] [-q|--quiet] [<stash>]"),
+	N_("git stash--helper branch <branchname> [<stash>]"),
 	N_("git stash--helper clear"),
 	NULL
 };
@@ -28,6 +29,11 @@ static const char * const git_stash_helper_apply_usage[] = {
 	NULL
 };
 
+static const char * const git_stash_helper_branch_usage[] = {
+	N_("git stash--helper branch <branchname> [<stash>]"),
+	NULL
+};
+
 static const char * const git_stash_helper_clear_usage[] = {
 	N_("git stash--helper clear"),
 	NULL
@@ -539,6 +545,44 @@ static int drop_stash(int argc, const char **argv, const char *prefix)
 	return ret;
 }
 
+static int branch_stash(int argc, const char **argv, const char *prefix)
+{
+	int ret;
+	const char *branch = NULL;
+	struct stash_info info;
+	struct child_process cp = CHILD_PROCESS_INIT;
+	struct option options[] = {
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_branch_usage, 0);
+
+	if (!argc) {
+		fprintf_ln(stderr, _("No branch name specified"));
+		return -1;
+	}
+
+	branch = argv[0];
+
+	if (get_stash_info(&info, argc - 1, argv + 1))
+		return -1;
+
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "checkout", "-b", NULL);
+	argv_array_push(&cp.args, branch);
+	argv_array_push(&cp.args, oid_to_hex(&info.b_commit));
+	ret = run_command(&cp);
+	if (!ret)
+		ret = do_apply_stash(prefix, &info, 1, 0);
+	if (!ret && info.is_stash_ref)
+		ret = do_drop_stash(prefix, &info, 0);
+
+	free_stash_info(&info);
+
+	return ret;
+}
+
 int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 {
 	pid_t pid = getpid();
@@ -565,6 +609,8 @@ int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 		return !!clear_stash(argc, argv, prefix);
 	else if (!strcmp(argv[0], "drop"))
 		return !!drop_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "branch"))
+		return !!branch_stash(argc, argv, prefix);
 
 	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
 		      git_stash_helper_usage, options);
git-stash.sh +2 -15
index a99d5dc9e5..29d9f44255 100755
@@ -598,20 +598,6 @@ drop_stash () {
 	clear_stash
 }
 
-apply_to_branch () {
-	test -n "$1" || die "$(gettext "No branch name specified")"
-	branch=$1
-	shift 1
-
-	set -- --index "$@"
-	assert_stash_like "$@"
-
-	git checkout -b $branch $REV^ &&
-	apply_stash "$@" && {
-		test -z "$IS_STASH_REF" || drop_stash "$@"
-	}
-}
-
 test "$1" = "-p" && set "push" "$@"
 
 PARSE_CACHE='--not-parsed'
@@ -673,7 +659,8 @@ pop)
 	;;
 branch)
 	shift
-	apply_to_branch "$@"
+	cd "$START_DIR"
+	git stash--helper branch "$@"
 	;;
 *)
 	case $# in
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#14 lore raw

PATCH v10 11/21 stash: convert pop to builtin

In reply to Paul-Sebastian Ungureanu

From: Joel Teichroeb <[email protected]>

Add stash pop to the helper and delete the pop_stash, drop_stash, assert_stash_ref functions from the shell script now that they are no longer needed.

---
 builtin/stash--helper.c | 39 +++++++++++++++++++++++++++++++++-
 git-stash.sh            | 47 ++---------------------------------------
 2 files changed, 40 insertions(+), 46 deletions(-)
builtin/stash--helper.c +38 -1
index c41aad7036..33f4e83353 100644
@@ -13,7 +13,7 @@
 
 static const char * const git_stash_helper_usage[] = {
 	N_("git stash--helper drop [-q|--quiet] [<stash>]"),
-	N_("git stash--helper apply [--index] [-q|--quiet] [<stash>]"),
+	N_("git stash--helper ( pop | apply ) [--index] [-q|--quiet] [<stash>]"),
 	N_("git stash--helper branch <branchname> [<stash>]"),
 	N_("git stash--helper clear"),
 	NULL
@@ -24,6 +24,11 @@ static const char * const git_stash_helper_drop_usage[] = {
 	NULL
 };
 
+static const char * const git_stash_helper_pop_usage[] = {
+	N_("git stash--helper pop [--index] [-q|--quiet] [<stash>]"),
+	NULL
+};
+
 static const char * const git_stash_helper_apply_usage[] = {
 	N_("git stash--helper apply [--index] [-q|--quiet] [<stash>]"),
 	NULL
@@ -545,6 +550,36 @@ static int drop_stash(int argc, const char **argv, const char *prefix)
 	return ret;
 }
 
+static int pop_stash(int argc, const char **argv, const char *prefix)
+{
+	int ret;
+	int index = 0;
+	int quiet = 0;
+	struct stash_info info;
+	struct option options[] = {
+		OPT__QUIET(&quiet, N_("be quiet, only report errors")),
+		OPT_BOOL(0, "index", &index,
+			 N_("attempt to recreate the index")),
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_pop_usage, 0);
+
+	if (get_stash_info(&info, argc, argv))
+		return -1;
+
+	assert_stash_ref(&info);
+	if ((ret = do_apply_stash(prefix, &info, index, quiet)))
+		printf_ln(_("The stash entry is kept in case "
+			    "you need it again."));
+	else
+		ret = do_drop_stash(prefix, &info, quiet);
+
+	free_stash_info(&info);
+	return ret;
+}
+
 static int branch_stash(int argc, const char **argv, const char *prefix)
 {
 	int ret;
@@ -609,6 +644,8 @@ int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 		return !!clear_stash(argc, argv, prefix);
 	else if (!strcmp(argv[0], "drop"))
 		return !!drop_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "pop"))
+		return !!pop_stash(argc, argv, prefix);
 	else if (!strcmp(argv[0], "branch"))
 		return !!branch_stash(argc, argv, prefix);
 
git-stash.sh +2 -45

59 lines not on this page · raw message

Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#15 lore raw

PATCH v10 12/21 stash: convert list to builtin

In reply to Paul-Sebastian Ungureanu

Add stash list to the helper and delete the list_stash function from the shell script.

---
 builtin/stash--helper.c | 31 +++++++++++++++++++++++++++++++
 git-stash.sh            |  7 +------
 2 files changed, 32 insertions(+), 6 deletions(-)
builtin/stash--helper.c +31 -0
index 33f4e83353..a1249f6b76 100644
@@ -12,6 +12,7 @@
 #include "rerere.h"
 
 static const char * const git_stash_helper_usage[] = {
+	N_("git stash--helper list [<options>]"),
 	N_("git stash--helper drop [-q|--quiet] [<stash>]"),
 	N_("git stash--helper ( pop | apply ) [--index] [-q|--quiet] [<stash>]"),
 	N_("git stash--helper branch <branchname> [<stash>]"),
@@ -19,6 +20,11 @@ static const char * const git_stash_helper_usage[] = {
 	NULL
 };
 
+static const char * const git_stash_helper_list_usage[] = {
+	N_("git stash--helper list [<options>]"),
+	NULL
+};
+
 static const char * const git_stash_helper_drop_usage[] = {
 	N_("git stash--helper drop [-q|--quiet] [<stash>]"),
 	NULL
@@ -618,6 +624,29 @@ static int branch_stash(int argc, const char **argv, const char *prefix)
 	return ret;
 }
 
+static int list_stash(int argc, const char **argv, const char *prefix)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+	struct option options[] = {
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_list_usage,
+			     PARSE_OPT_KEEP_UNKNOWN);
+
+	if (!ref_exists(ref_stash))
+		return 0;
+
+	cp.git_cmd = 1;
+	argv_array_pushl(&cp.args, "log", "--format=%gd: %gs", "-g",
+			 "--first-parent", "-m", NULL);
+	argv_array_pushv(&cp.args, argv);
+	argv_array_push(&cp.args, ref_stash);
+	argv_array_push(&cp.args, "--");
+	return run_command(&cp);
+}
+
 int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 {
 	pid_t pid = getpid();
@@ -648,6 +677,8 @@ int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 		return !!pop_stash(argc, argv, prefix);
 	else if (!strcmp(argv[0], "branch"))
 		return !!branch_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "list"))
+		return !!list_stash(argc, argv, prefix);
 
 	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
 		      git_stash_helper_usage, options);
git-stash.sh +1 -6
index 8f2640fe90..6052441aa2 100755
@@ -382,11 +382,6 @@ have_stash () {
 	git rev-parse --verify --quiet $ref_stash >/dev/null
 }
 
-list_stash () {
-	have_stash || return 0
-	git log --format="%gd: %gs" -g --first-parent -m "$@" $ref_stash --
-}
-
 show_stash () {
 	ALLOW_UNKNOWN_FLAGS=t
 	assert_stash_like "$@"
@@ -574,7 +569,7 @@ test -n "$seen_non_option" || set "push" "$@"
 case "$1" in
 list)
 	shift
-	list_stash "$@"
+	git stash--helper list "$@"
 	;;
 show)
 	shift
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#16 lore raw

PATCH v10 13/21 stash: convert show to builtin

In reply to Paul-Sebastian Ungureanu

Add stash show to the helper and delete the show_stash, have_stash, assert_stash_like, is_stash_like and parse_flags_and_rev functions from the shell script now that they are no longer needed.

In shell version, although git stash show accepts --index and --quiet options, it ignores them. In C, both options are passed further to git diff.

---
 builtin/stash--helper.c |  87 ++++++++++++++++++++++++++
 git-stash.sh            | 132 +---------------------------------------
 2 files changed, 88 insertions(+), 131 deletions(-)
builtin/stash--helper.c +87 -0
index a1249f6b76..3f7ace92f5 100644
@@ -10,9 +10,12 @@
 #include "run-command.h"
 #include "dir.h"
 #include "rerere.h"
+#include "revision.h"
+#include "log-tree.h"
 
 static const char * const git_stash_helper_usage[] = {
 	N_("git stash--helper list [<options>]"),
+	N_("git stash--helper show [<options>] [<stash>]"),
 	N_("git stash--helper drop [-q|--quiet] [<stash>]"),
 	N_("git stash--helper ( pop | apply ) [--index] [-q|--quiet] [<stash>]"),
 	N_("git stash--helper branch <branchname> [<stash>]"),
@@ -25,6 +28,11 @@ static const char * const git_stash_helper_list_usage[] = {
 	NULL
 };
 
+static const char * const git_stash_helper_show_usage[] = {
+	N_("git stash--helper show [<options>] [<stash>]"),
+	NULL
+};
+
 static const char * const git_stash_helper_drop_usage[] = {
 	N_("git stash--helper drop [-q|--quiet] [<stash>]"),
 	NULL
@@ -647,6 +655,83 @@ static int list_stash(int argc, const char **argv, const char *prefix)
 	return run_command(&cp);
 }
 
+static int show_stat = 1;
+static int show_patch;
+
+static int git_stash_config(const char *var, const char *value, void *cb)
+{
+	if (!strcmp(var, "stash.showstat")) {
+		show_stat = git_config_bool(var, value);
+		return 0;
+	}
+	if (!strcmp(var, "stash.showpatch")) {
+		show_patch = git_config_bool(var, value);
+		return 0;
+	}
+	return git_default_config(var, value, cb);
+}
+
+static int show_stash(int argc, const char **argv, const char *prefix)
+{
+	int i;
+	int opts = 0;
+	int ret = 0;
+	struct stash_info info;
+	struct rev_info rev;
+	struct argv_array stash_args = ARGV_ARRAY_INIT;
+	struct option options[] = {
+		OPT_END()
+	};
+
+	init_diff_ui_defaults();
+	git_config(git_diff_ui_config, NULL);
+	init_revisions(&rev, prefix);
+
+	for (i = 1; i < argc; i++) {
+		if (argv[i][0] != '-')
+			argv_array_push(&stash_args, argv[i]);
+		else
+			opts++;
+	}
+
+	ret = get_stash_info(&info, stash_args.argc, stash_args.argv);
+	argv_array_clear(&stash_args);
+	if (ret)
+		return -1;
+
+	/*
+	 * The config settings are applied only if there are not passed
+	 * any options.
+	 */
+	if (!opts) {
+		git_config(git_stash_config, NULL);
+		if (show_stat)
+			rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT;
+
+		if (show_patch)
+			rev.diffopt.output_format |= DIFF_FORMAT_PATCH;
+
+		if (!show_stat && !show_patch) {
+			free_stash_info(&info);
+			return 0;
+		}
+	}
+
+	argc = setup_revisions(argc, argv, &rev, NULL);
+	if (argc > 1) {
+		free_stash_info(&info);
+		usage_with_options(git_stash_helper_show_usage, options);
+	}
+
+	rev.diffopt.flags.recursive = 1;
+	setup_diff_pager(&rev.diffopt);
+	diff_tree_oid(&info.b_commit, &info.w_commit, "", &rev.diffopt);
+	log_tree_diff_flush(&rev);
+
+	free_stash_info(&info);
+	return diff_result_code(&rev.diffopt, 0);
+}
+
 int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 {
 	pid_t pid = getpid();
@@ -679,6 +764,8 @@ int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 		return !!branch_stash(argc, argv, prefix);
 	else if (!strcmp(argv[0], "list"))
 		return !!list_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "show"))
+		return !!show_stash(argc, argv, prefix);
 
 	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
 		      git_stash_helper_usage, options);
git-stash.sh +1 -131

150 lines not on this page · raw message

Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#17 lore raw

PATCH v10 14/21 stash: convert store to builtin

In reply to Paul-Sebastian Ungureanu

Add stash store to the helper and delete the store_stash function from the shell script.

---
 builtin/stash--helper.c | 62 +++++++++++++++++++++++++++++++++++++++++
 git-stash.sh            | 43 ++--------------------------
 2 files changed, 64 insertions(+), 41 deletions(-)
builtin/stash--helper.c +62 -0
index 3f7ace92f5..758a32572d 100644
@@ -58,6 +58,11 @@ static const char * const git_stash_helper_clear_usage[] = {
 	NULL
 };
 
+static const char * const git_stash_helper_store_usage[] = {
+	N_("git stash--helper store [-m|--message <message>] [-q|--quiet] <commit>"),
+	NULL
+};
+
 static const char *ref_stash = "refs/stash";
 static struct strbuf stash_index_path = STRBUF_INIT;
 
@@ -732,6 +737,61 @@ static int show_stash(int argc, const char **argv, const char *prefix)
 	return diff_result_code(&rev.diffopt, 0);
 }
 
+static int do_store_stash(const struct object_id *w_commit, const char *stash_msg,
+			  int quiet)
+{
+	if (!stash_msg)
+		stash_msg = "Created via \"git stash store\".";
+
+	if (update_ref(stash_msg, ref_stash, w_commit, NULL,
+		       REF_FORCE_CREATE_REFLOG,
+		       quiet ? UPDATE_REFS_QUIET_ON_ERR :
+		       UPDATE_REFS_MSG_ON_ERR)) {
+		if (!quiet) {
+			fprintf_ln(stderr, _("Cannot update %s with %s"),
+				   ref_stash, oid_to_hex(w_commit));
+		}
+		return -1;
+	}
+
+	return 0;
+}
+
+static int store_stash(int argc, const char **argv, const char *prefix)
+{
+	int quiet = 0;
+	const char *stash_msg = NULL;
+	struct object_id obj;
+	struct object_context dummy;
+	struct option options[] = {
+		OPT__QUIET(&quiet, N_("be quiet")),
+		OPT_STRING('m', "message", &stash_msg, "message",
+			   N_("stash message")),
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_store_usage,
+			     PARSE_OPT_KEEP_UNKNOWN);
+
+	if (argc != 1) {
+		if (!quiet)
+			fprintf_ln(stderr, _("\"git stash store\" requires one "
+					     "<commit> argument"));
+		return -1;
+	}
+
+	if (get_oid_with_context(argv[0], quiet ? GET_OID_QUIETLY : 0, &obj,
+				 &dummy)) {
+		if (!quiet)
+			fprintf_ln(stderr, _("Cannot update %s with %s"),
+					     ref_stash, argv[0]);
+		return -1;
+	}
+
+	return do_store_stash(&obj, stash_msg, quiet);
+}
+
 int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 {
 	pid_t pid = getpid();
@@ -766,6 +826,8 @@ int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 		return !!list_stash(argc, argv, prefix);
 	else if (!strcmp(argv[0], "show"))
 		return !!show_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "store"))
+		return !!store_stash(argc, argv, prefix);
 
 	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
 		      git_stash_helper_usage, options);
git-stash.sh +2 -41

61 lines not on this page · raw message

Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#18 lore raw

PATCH v10 15/21 stash: convert create to builtin

In reply to Paul-Sebastian Ungureanu

Add stash create to the helper.

---
 builtin/stash--helper.c | 458 ++++++++++++++++++++++++++++++++++++++++
 git-stash.sh            |   2 +-
 2 files changed, 459 insertions(+), 1 deletion(-)
builtin/stash--helper.c +458 -0
index 758a32572d..b8e69c1050 100644
@@ -12,6 +12,9 @@
 #include "rerere.h"
 #include "revision.h"
 #include "log-tree.h"
+#include "diffcore.h"
+
+#define INCLUDE_ALL_FILES 2
 
 static const char * const git_stash_helper_usage[] = {
 	N_("git stash--helper list [<options>]"),
@@ -63,6 +66,11 @@ static const char * const git_stash_helper_store_usage[] = {
 	NULL
 };
 
+static const char * const git_stash_helper_create_usage[] = {
+	N_("git stash--helper create [<message>]"),
+	NULL
+};
+
 static const char *ref_stash = "refs/stash";
 static struct strbuf stash_index_path = STRBUF_INIT;
 
@@ -290,6 +298,24 @@ static int reset_head(void)
 	return run_command(&cp);
 }
 
+static void add_diff_to_buf(struct diff_queue_struct *q,
+			    struct diff_options *options,
+			    void *data)
+{
+	int i;
+
+	for (i = 0; i < q->nr; i++) {
+		strbuf_addstr(data, q->queue[i]->one->path);
+
+		/*
+		 * The reason we add "0" at the end of this strbuf
+		 * is because we will pass the output further to
+		 * "git update-index -z ...".
+		 */
+		strbuf_addch(data, '\0');
+	}
+}
+
 static int get_newly_staged(struct strbuf *out, struct object_id *c_tree)
 {
 	struct child_process cp = CHILD_PROCESS_INIT;
@@ -792,6 +818,436 @@ static int store_stash(int argc, const char **argv, const char *prefix)
 	return do_store_stash(&obj, stash_msg, quiet);
 }
 
+static void add_pathspecs(struct argv_array *args,
+			  struct pathspec ps) {
+	int i;
+
+	for (i = 0; i < ps.nr; i++)
+		argv_array_push(args, ps.items[i].match);
+}
+
+/*
+ * `untracked_files` will be filled with the names of untracked files.
+ * The return value is:
+ *
+ * = 0 if there are not any untracked files
+ * > 0 if there are untracked files
+ */
+static int get_untracked_files(struct pathspec ps, int include_untracked,
+			       struct strbuf *untracked_files)
+{
+	int i;
+	int max_len;
+	int found = 0;
+	char *seen;
+	struct dir_struct dir;
+
+	memset(&dir, 0, sizeof(dir));
+	if (include_untracked != INCLUDE_ALL_FILES)
+		setup_standard_excludes(&dir);
+
+	seen = xcalloc(ps.nr, 1);
+
+	max_len = fill_directory(&dir, the_repository->index, &ps);
+	for (i = 0; i < dir.nr; i++) {
+		struct dir_entry *ent = dir.entries[i];
+		if (dir_path_match(&the_index, ent, &ps, max_len, seen)) {
+			found++;
+			strbuf_addstr(untracked_files, ent->name);
+			/* NUL-terminate: will be fed to update-index -z */
+			strbuf_addch(untracked_files, 0);
+		}
+		free(ent);
+	}
+
+	free(seen);
+	free(dir.entries);
+	free(dir.ignored);
+	clear_directory(&dir);
+	return found;
+}
+
+/*
+ * The return value of `check_changes()` can be:
+ *
+ * < 0 if there was an error
+ * = 0 if there are no changes.
+ * > 0 if there are changes.
+ */
+static int check_changes(struct pathspec ps, int include_untracked)
+{
+	int result;
+	struct rev_info rev;
+	struct object_id dummy;
+	struct strbuf out = STRBUF_INIT;
+
+	/* No initial commit. */
+	if (get_oid("HEAD", &dummy))
+		return -1;
+
+	if (read_cache() < 0)
+		return -1;
+
+	init_revisions(&rev, NULL);
+	rev.prune_data = ps;
+
+	rev.diffopt.flags.quick = 1;
+	rev.diffopt.flags.ignore_submodules = 1;
+	rev.abbrev = 0;
+
+	add_head_to_pending(&rev);
+	diff_setup_done(&rev.diffopt);
+
+	result = run_diff_index(&rev, 1);
+	if (diff_result_code(&rev.diffopt, result))
+		return 1;
+
+	object_array_clear(&rev.pending);
+	result = run_diff_files(&rev, 0);
+	if (diff_result_code(&rev.diffopt, result))
+		return 1;
+
+	if (include_untracked && get_untracked_files(ps, include_untracked,
+						     &out)) {
+		strbuf_release(&out);
+		return 1;
+	}
+
+	strbuf_release(&out);
+	return 0;
+}
+
+static int save_untracked_files(struct stash_info *info, struct strbuf *msg,
+				struct strbuf files)
+{
+	int ret = 0;
+	struct strbuf untracked_msg = STRBUF_INIT;
+	struct strbuf out = STRBUF_INIT;
+	struct child_process cp_upd_index = CHILD_PROCESS_INIT;
+	struct child_process cp_write_tree = CHILD_PROCESS_INIT;
+
+	cp_upd_index.git_cmd = 1;
+	argv_array_pushl(&cp_upd_index.args, "update-index", "-z", "--add",
+			 "--remove", "--stdin", NULL);
+	argv_array_pushf(&cp_upd_index.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+
+	strbuf_addf(&untracked_msg, "untracked files on %s\n", msg->buf);
+	if (pipe_command(&cp_upd_index, files.buf, files.len, NULL, 0,
+			 NULL, 0)) {
+		ret = -1;
+		goto done;
+	}
+
+	cp_write_tree.git_cmd = 1;
+	argv_array_push(&cp_write_tree.args, "write-tree");
+	argv_array_pushf(&cp_write_tree.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+	if (pipe_command(&cp_write_tree, NULL, 0, &out, 0,NULL, 0)) {
+		ret = -1;
+		goto done;
+	}
+	get_oid_hex(out.buf, &info->u_tree);
+
+	if (commit_tree(untracked_msg.buf, untracked_msg.len,
+			&info->u_tree, NULL, &info->u_commit, NULL, NULL)) {
+		ret = -1;
+		goto done;
+	}
+
+done:
+	strbuf_release(&untracked_msg);
+	strbuf_release(&out);
+	remove_path(stash_index_path.buf);
+	return ret;
+}
+
+static int stash_patch(struct stash_info *info, struct pathspec ps,
+		       struct strbuf *out_patch)
+{
+	int ret = 0;
+	struct strbuf out = STRBUF_INIT;
+	struct child_process cp_read_tree = CHILD_PROCESS_INIT;
+	struct child_process cp_add_i = CHILD_PROCESS_INIT;
+	struct child_process cp_write_tree = CHILD_PROCESS_INIT;
+	struct child_process cp_diff_tree = CHILD_PROCESS_INIT;
+
+	remove_path(stash_index_path.buf);
+
+	cp_read_tree.git_cmd = 1;
+	argv_array_pushl(&cp_read_tree.args, "read-tree", "HEAD", NULL);
+	argv_array_pushf(&cp_read_tree.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+	if (run_command(&cp_read_tree)) {
+		ret = -1;
+		goto done;
+	}
+
+	/* Find out what the user wants. */
+	cp_add_i.git_cmd = 1;
+	argv_array_pushl(&cp_add_i.args, "add--interactive", "--patch=stash",
+			 "--", NULL);
+	add_pathspecs(&cp_add_i.args, ps);
+	argv_array_pushf(&cp_add_i.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+	if (run_command(&cp_add_i)) {
+		ret = -1;
+		goto done;
+	}
+
+	/* State of the working tree. */
+	cp_write_tree.git_cmd = 1;
+	argv_array_push(&cp_write_tree.args, "write-tree");
+	argv_array_pushf(&cp_write_tree.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+	if (pipe_command(&cp_write_tree, NULL, 0, &out, 0,NULL, 0)) {
+		ret = -1;
+		goto done;
+	}
+
+	get_oid_hex(out.buf, &info->w_tree);
+
+	cp_diff_tree.git_cmd = 1;
+	argv_array_pushl(&cp_diff_tree.args, "diff-tree", "-p", "HEAD",
+			 oid_to_hex(&info->w_tree), "--", NULL);
+	if (pipe_command(&cp_diff_tree, NULL, 0, out_patch, 0, NULL, 0)) {
+		ret = -1;
+		goto done;
+	}
+
+	if (!out_patch->len) {
+		fprintf_ln(stderr, _("No changes selected"));
+		ret = 1;
+	}
+
+done:
+	strbuf_release(&out);
+	remove_path(stash_index_path.buf);
+	return ret;
+}
+
+static int stash_working_tree(struct stash_info *info, struct pathspec ps)
+{
+	int ret = 0;
+	struct rev_info rev;
+	struct child_process cp_upd_index = CHILD_PROCESS_INIT;
+	struct child_process cp_write_tree = CHILD_PROCESS_INIT;
+	struct strbuf out = STRBUF_INIT;
+	struct strbuf diff_output = STRBUF_INIT;
+
+	set_alternate_index_output(stash_index_path.buf);
+	if (reset_tree(&info->i_tree, 0, 0)) {
+		ret = -1;
+		goto done;
+	}
+	set_alternate_index_output(NULL);
+
+	git_config(git_diff_basic_config, NULL);
+	init_revisions(&rev, NULL);
+	rev.prune_data = ps;
+	rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
+	rev.diffopt.format_callback = add_diff_to_buf;
+	rev.diffopt.format_callback_data = &diff_output;
+
+	if (read_cache_preload(&rev.diffopt.pathspec) < 0) {
+		ret = -1;
+		goto done;
+	}
+
+	add_pending_object(&rev, parse_object(the_repository, &info->b_commit),
+			   "");
+	if (run_diff_index(&rev, 0)) {
+		ret = -1;
+		goto done;
+	}
+
+	cp_upd_index.git_cmd = 1;
+	argv_array_pushl(&cp_upd_index.args, "update-index", "-z", "--add",
+			 "--remove", "--stdin", NULL);
+	argv_array_pushf(&cp_upd_index.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+
+	if (pipe_command(&cp_upd_index, diff_output.buf, diff_output.len,
+			 NULL, 0, NULL, 0)) {
+		ret = -1;
+		goto done;
+	}
+
+	cp_write_tree.git_cmd = 1;
+	argv_array_push(&cp_write_tree.args, "write-tree");
+	argv_array_pushf(&cp_write_tree.env_array, "GIT_INDEX_FILE=%s",
+			 stash_index_path.buf);
+	if (pipe_command(&cp_write_tree, NULL, 0, &out, 0,NULL, 0)) {
+		ret = -1;
+		goto done;
+	}
+
+	get_oid_hex(out.buf, &info->w_tree);
+
+done:
+	UNLEAK(rev);
+	strbuf_release(&out);
+	object_array_clear(&rev.pending);
+	strbuf_release(&diff_output);
+	remove_path(stash_index_path.buf);
+	return ret;
+}
+
+static int do_create_stash(struct pathspec ps, char **stash_msg,
+			   int include_untracked, int patch_mode,
+			   struct stash_info *info)
+{
+	int ret = 0;
+	int flags = 0;
+	int untracked_commit_option = 0;
+	const char *head_short_sha1 = NULL;
+	const char *branch_ref = NULL;
+	const char *branch_name = "(no branch)";
+	struct commit *head_commit = NULL;
+	struct commit_list *parents = NULL;
+	struct strbuf msg = STRBUF_INIT;
+	struct strbuf commit_tree_label = STRBUF_INIT;
+	struct strbuf untracked_files = STRBUF_INIT;
+	struct strbuf stash_msg_buf = STRBUF_INIT;
+	struct strbuf patch = STRBUF_INIT;
+
+	read_cache_preload(NULL);
+	refresh_cache(REFRESH_QUIET);
+
+	if (get_oid("HEAD", &info->b_commit)) {
+		fprintf_ln(stderr, _("You do not have the initial commit yet"));
+		ret = -1;
+		*stash_msg = NULL;
+		goto done;
+	} else {
+		head_commit = lookup_commit(the_repository, &info->b_commit);
+	}
+
+	if (!check_changes(ps, include_untracked)) {
+		ret = 1;
+		*stash_msg = NULL;
+		goto done;
+	}
+
+	branch_ref = resolve_ref_unsafe("HEAD", 0, NULL, &flags);
+	if (flags & REF_ISSYMREF)
+		branch_name = strrchr(branch_ref, '/') + 1;
+	head_short_sha1 = find_unique_abbrev(&head_commit->object.oid,
+					     DEFAULT_ABBREV);
+	strbuf_addf(&msg, "%s: %s ", branch_name, head_short_sha1);
+	pp_commit_easy(CMIT_FMT_ONELINE, head_commit, &msg);
+
+	strbuf_addf(&commit_tree_label, "index on %s\n", msg.buf);
+	commit_list_insert(head_commit, &parents);
+	if (write_cache_as_tree(&info->i_tree, 0, NULL) ||
+	    commit_tree(commit_tree_label.buf, commit_tree_label.len,
+			&info->i_tree, parents, &info->i_commit, NULL, NULL)) {
+		fprintf_ln(stderr, _("Cannot save the current index state"));
+		ret = -1;
+		*stash_msg = NULL;
+		goto done;
+	}
+
+	if (include_untracked && get_untracked_files(ps, include_untracked,
+						     &untracked_files)) {
+		if (save_untracked_files(info, &msg, untracked_files)) {
+			fprintf_ln(stderr, _("Cannot save "
+					     "the untracked files"));
+			ret = -1;
+			*stash_msg = NULL;
+			goto done;
+		}
+		untracked_commit_option = 1;
+	}
+	if (patch_mode) {
+		ret = stash_patch(info, ps, &patch);
+		*stash_msg = NULL;
+		if (ret < 0) {
+			fprintf_ln(stderr, _("Cannot save the current "
+					     "worktree state"));
+			goto done;
+		} else if (ret > 0) {
+			goto done;
+		}
+	} else {
+		if (stash_working_tree(info, ps)) {
+			fprintf_ln(stderr, _("Cannot save the current "
+					     "worktree state"));
+			ret = -1;
+			*stash_msg = NULL;
+			goto done;
+		}
+	}
+
+	if (!*stash_msg || !strlen(*stash_msg))
+		strbuf_addf(&stash_msg_buf, "WIP on %s", msg.buf);
+	else
+		strbuf_addf(&stash_msg_buf, "On %s: %s", branch_name,
+			    *stash_msg);
+	*stash_msg = strbuf_detach(&stash_msg_buf, NULL);
+
+	/*
+	 * `parents` will be empty after calling `commit_tree()`, so there is
+	 * no need to call `free_commit_list()`
+	 */
+	parents = NULL;
+	if (untracked_commit_option)
+		commit_list_insert(lookup_commit(the_repository,
+						 &info->u_commit),
+				   &parents);
+	commit_list_insert(lookup_commit(the_repository, &info->i_commit),
+			   &parents);
+	commit_list_insert(head_commit, &parents);
+
+	if (commit_tree(*stash_msg, strlen(*stash_msg), &info->w_tree,
+			parents, &info->w_commit, NULL, NULL)) {
+		fprintf_ln(stderr, _("Cannot record working tree state"));
+		ret = -1;
+		goto done;
+	}
+
+done:
+	strbuf_release(&commit_tree_label);
+	strbuf_release(&msg);
+	strbuf_release(&untracked_files);
+	strbuf_release(&stash_msg_buf);
+	return ret;
+}
+
+static int create_stash(int argc, const char **argv, const char *prefix)
+{
+	int include_untracked = 0;
+	int ret = 0;
+	char *stash_msg = NULL;
+	struct stash_info info;
+	struct pathspec ps;
+	struct option options[] = {
+		OPT_BOOL('u', "include-untracked", &include_untracked,
+			 N_("include untracked files in stash")),
+		OPT_STRING('m', "message", &stash_msg, N_("message"),
+			 N_("stash message")),
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_create_usage,
+			     0);
+
+	memset(&ps, 0, sizeof(ps));
+	ret = do_create_stash(ps, &stash_msg, include_untracked, 0, &info);
+
+	if (!ret)
+		printf_ln("%s", oid_to_hex(&info.w_commit));
+
+	free(stash_msg);
+
+	/*
+	 * ret can be 1 if there were no changes. In this case, we should
+	 * not error out.
+	 */
+	return ret < 0;
+}
+
 int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 {
 	pid_t pid = getpid();
@@ -828,6 +1284,8 @@ int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 		return !!show_stash(argc, argv, prefix);
 	else if (!strcmp(argv[0], "store"))
 		return !!store_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "create"))
+		return !!create_stash(argc, argv, prefix);
 
 	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
 		      git_stash_helper_usage, options);
git-stash.sh +1 -1
index 5739c51527..ab06e4ffb8 100755
@@ -425,7 +425,7 @@ clear)
 	;;
 create)
 	shift
-	create_stash -m "$*" && echo "$w_commit"
+	git stash--helper create --message "$*"
 	;;
 store)
 	shift
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#19 lore raw

PATCH v10 16/21 stash: convert push to builtin

In reply to Paul-Sebastian Ungureanu

Add stash push to the helper.

---
 builtin/stash--helper.c | 241 +++++++++++++++++++++++++++++++++++++++-
 git-stash.sh            |   6 +-
 2 files changed, 241 insertions(+), 6 deletions(-)
builtin/stash--helper.c +237 -4
index b8e69c1050..23f1329637 100644
@@ -23,6 +23,9 @@ static const char * const git_stash_helper_usage[] = {
 	N_("git stash--helper ( pop | apply ) [--index] [-q|--quiet] [<stash>]"),
 	N_("git stash--helper branch <branchname> [<stash>]"),
 	N_("git stash--helper clear"),
+	N_("git stash--helper [push [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]\n"
+	   "          [-u|--include-untracked] [-a|--all] [-m|--message <message>]\n"
+	   "          [--] [<pathspec>...]]"),
 	NULL
 };
 
@@ -71,6 +74,13 @@ static const char * const git_stash_helper_create_usage[] = {
 	NULL
 };
 
+static const char * const git_stash_helper_push_usage[] = {
+	N_("git stash--helper [push [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]\n"
+	   "          [-u|--include-untracked] [-a|--all] [-m|--message <message>]\n"
+	   "          [--] [<pathspec>...]]"),
+	NULL
+};
+
 static const char *ref_stash = "refs/stash";
 static struct strbuf stash_index_path = STRBUF_INIT;
 
@@ -1095,7 +1105,7 @@ static int stash_working_tree(struct stash_info *info, struct pathspec ps)
 
 static int do_create_stash(struct pathspec ps, char **stash_msg,
 			   int include_untracked, int patch_mode,
-			   struct stash_info *info)
+			   struct stash_info *info, struct strbuf *patch)
 {
 	int ret = 0;
 	int flags = 0;
@@ -1109,7 +1119,6 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 	struct strbuf commit_tree_label = STRBUF_INIT;
 	struct strbuf untracked_files = STRBUF_INIT;
 	struct strbuf stash_msg_buf = STRBUF_INIT;
-	struct strbuf patch = STRBUF_INIT;
 
 	read_cache_preload(NULL);
 	refresh_cache(REFRESH_QUIET);
@@ -1160,7 +1169,7 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 		untracked_commit_option = 1;
 	}
 	if (patch_mode) {
-		ret = stash_patch(info, ps, &patch);
+		ret = stash_patch(info, ps, patch);
 		*stash_msg = NULL;
 		if (ret < 0) {
 			fprintf_ln(stderr, _("Cannot save the current "
@@ -1234,7 +1243,8 @@ static int create_stash(int argc, const char **argv, const char *prefix)
 			     0);
 
 	memset(&ps, 0, sizeof(ps));
-	ret = do_create_stash(ps, &stash_msg, include_untracked, 0, &info);
+	ret = do_create_stash(ps, &stash_msg, include_untracked, 0, &info,
+			      NULL);
 
 	if (!ret)
 		printf_ln("%s", oid_to_hex(&info.w_commit));
@@ -1248,6 +1258,227 @@ static int create_stash(int argc, const char **argv, const char *prefix)
 	return ret < 0;
 }
 
+static int do_push_stash(struct pathspec ps, char *stash_msg, int quiet,
+			 int keep_index, int patch_mode, int include_untracked)
+{
+	int ret = 0;
+	struct stash_info info;
+	struct strbuf patch = STRBUF_INIT;
+
+	if (patch_mode && keep_index == -1)
+		keep_index = 1;
+
+	if (patch_mode && include_untracked) {
+		fprintf_ln(stderr, _("Can't use --patch and --include-untracked"
+				     " or --all at the same time"));
+		ret = -1;
+		goto done;
+	}
+
+	read_cache_preload(NULL);
+	if (!include_untracked && ps.nr) {
+		int i;
+		char *ps_matched = xcalloc(ps.nr, 1);
+
+		for (i = 0; i < active_nr; i++)
+			ce_path_match(&the_index, active_cache[i], &ps,
+				      ps_matched);
+
+		if (report_path_error(ps_matched, &ps, NULL)) {
+			fprintf_ln(stderr, _("Did you forget to 'git add'?"));
+			ret = -1;
+			free(ps_matched);
+			goto done;
+		}
+		free(ps_matched);
+	}
+
+	if (refresh_cache(REFRESH_QUIET)) {
+		ret = -1;
+		goto done;
+	}
+
+	if (!check_changes(ps, include_untracked)) {
+		if (!quiet)
+			printf_ln(_("No local changes to save"));
+		goto done;
+	}
+
+	if (!reflog_exists(ref_stash) && do_clear_stash()) {
+		ret = -1;
+		fprintf_ln(stderr, _("Cannot initialize stash"));
+		goto done;
+	}
+
+	if (do_create_stash(ps, &stash_msg, include_untracked, patch_mode,
+			    &info, &patch)) {
+		ret = -1;
+		goto done;
+	}
+
+	if (do_store_stash(&info.w_commit, stash_msg, 1)) {
+		ret = -1;
+		fprintf_ln(stderr, _("Cannot save the current status"));
+		goto done;
+	}
+
+	printf_ln(_("Saved working directory and index state %s"), stash_msg);
+
+	if (!patch_mode) {
+		if (include_untracked && !ps.nr) {
+			struct child_process cp = CHILD_PROCESS_INIT;
+
+			cp.git_cmd = 1;
+			argv_array_pushl(&cp.args, "clean", "--force",
+					 "--quiet", "-d", NULL);
+			if (include_untracked == INCLUDE_ALL_FILES)
+				argv_array_push(&cp.args, "-x");
+			if (run_command(&cp)) {
+				ret = -1;
+				goto done;
+			}
+		}
+		if (ps.nr) {
+			struct child_process cp_add = CHILD_PROCESS_INIT;
+			struct child_process cp_diff = CHILD_PROCESS_INIT;
+			struct child_process cp_apply = CHILD_PROCESS_INIT;
+			struct strbuf out = STRBUF_INIT;
+
+			cp_add.git_cmd = 1;
+			argv_array_push(&cp_add.args, "add");
+			if (!include_untracked)
+				argv_array_push(&cp_add.args, "-u");
+			if (include_untracked == INCLUDE_ALL_FILES)
+				argv_array_push(&cp_add.args, "--force");
+			argv_array_push(&cp_add.args, "--");
+			add_pathspecs(&cp_add.args, ps);
+			if (run_command(&cp_add)) {
+				ret = -1;
+				goto done;
+			}
+
+			cp_diff.git_cmd = 1;
+			argv_array_pushl(&cp_diff.args, "diff-index", "-p",
+					 "--cached", "--binary", "HEAD", "--",
+					 NULL);
+			add_pathspecs(&cp_diff.args, ps);
+			if (pipe_command(&cp_diff, NULL, 0, &out, 0, NULL, 0)) {
+				ret = -1;
+				goto done;
+			}
+
+			cp_apply.git_cmd = 1;
+			argv_array_pushl(&cp_apply.args, "apply", "--index",
+					 "-R", NULL);
+			if (pipe_command(&cp_apply, out.buf, out.len, NULL, 0,
+					 NULL, 0)) {
+				ret = -1;
+				goto done;
+			}
+		} else {
+			struct child_process cp = CHILD_PROCESS_INIT;
+			cp.git_cmd = 1;
+			argv_array_pushl(&cp.args, "reset", "--hard", "-q",
+					 NULL);
+			if (run_command(&cp)) {
+				ret = -1;
+				goto done;
+			}
+		}
+
+		if (keep_index == 1 && !is_null_oid(&info.i_tree)) {
+			struct child_process cp_ls = CHILD_PROCESS_INIT;
+			struct child_process cp_checkout = CHILD_PROCESS_INIT;
+			struct strbuf out = STRBUF_INIT;
+
+			if (reset_tree(&info.i_tree, 0, 1)) {
+				ret = -1;
+				goto done;
+			}
+
+			cp_ls.git_cmd = 1;
+			argv_array_pushl(&cp_ls.args, "ls-files", "-z",
+					 "--modified", "--", NULL);
+
+			add_pathspecs(&cp_ls.args, ps);
+			if (pipe_command(&cp_ls, NULL, 0, &out, 0, NULL, 0)) {
+				ret = -1;
+				goto done;
+			}
+
+			cp_checkout.git_cmd = 1;
+			argv_array_pushl(&cp_checkout.args, "checkout-index",
+					 "-z", "--force", "--stdin", NULL);
+			if (pipe_command(&cp_checkout, out.buf, out.len, NULL,
+					 0, NULL, 0)) {
+				ret = -1;
+				goto done;
+			}
+		}
+		goto done;
+	} else {
+		struct child_process cp = CHILD_PROCESS_INIT;
+
+		cp.git_cmd = 1;
+		argv_array_pushl(&cp.args, "apply", "-R", NULL);
+
+		if (pipe_command(&cp, patch.buf, patch.len, NULL, 0, NULL, 0)) {
+			fprintf_ln(stderr, _("Cannot remove worktree changes"));
+			ret = -1;
+			goto done;
+		}
+
+		if (keep_index < 1) {
+			struct child_process cp = CHILD_PROCESS_INIT;
+
+			cp.git_cmd = 1;
+			argv_array_pushl(&cp.args, "reset", "-q", "--", NULL);
+			add_pathspecs(&cp.args, ps);
+			if (run_command(&cp)) {
+				ret = -1;
+				goto done;
+			}
+		}
+		goto done;
+	}
+
+done:
+	free(stash_msg);
+	return ret;
+}
+
+static int push_stash(int argc, const char **argv, const char *prefix)
+{
+	int keep_index = -1;
+	int patch_mode = 0;
+	int include_untracked = 0;
+	int quiet = 0;
+	char *stash_msg = NULL;
+	struct pathspec ps;
+	struct option options[] = {
+		OPT_BOOL('k', "keep-index", &keep_index,
+			 N_("keep index")),
+		OPT_BOOL('p', "patch", &patch_mode,
+			 N_("stash in patch mode")),
+		OPT__QUIET(&quiet, N_("quiet mode")),
+		OPT_BOOL('u', "include-untracked", &include_untracked,
+			 N_("include untracked files in stash")),
+		OPT_SET_INT('a', "all", &include_untracked,
+			    N_("include ignore files"), 2),
+		OPT_STRING('m', "message", &stash_msg, N_("message"),
+			   N_("stash message")),
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_push_usage,
+			     0);
+
+	parse_pathspec(&ps, 0, PATHSPEC_PREFER_FULL, prefix, argv);
+	return do_push_stash(ps, xstrdup_or_null(stash_msg), quiet,
+			     keep_index, patch_mode, include_untracked);
+}
+
 int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 {
 	pid_t pid = getpid();
@@ -1286,6 +1517,8 @@ int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 		return !!store_stash(argc, argv, prefix);
 	else if (!strcmp(argv[0], "create"))
 		return !!create_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "push"))
+		return !!push_stash(argc, argv, prefix);
 
 	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
 		      git_stash_helper_usage, options);
git-stash.sh +4 -2
index ab06e4ffb8..c3146f62ab 100755
@@ -412,7 +412,8 @@ save)
 	;;
 push)
 	shift
-	push_stash "$@"
+	cd "$START_DIR"
+	git stash--helper push "$@"
 	;;
 apply)
 	shift
@@ -448,7 +449,8 @@ branch)
 *)
 	case $# in
 	0)
-		push_stash &&
+		cd "$START_DIR"
+		git stash--helper push &&
 		say "$(gettext "(To restore them type \"git stash apply\")")"
 		;;
 	*)
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#20 lore raw

PATCH v10 17/21 stash: make push -q quiet

In reply to Paul-Sebastian Ungureanu

There is a change in behaviour with this commit. When there was no initial commit, the shell version of stash would still display a message. This commit makes push to not display any message if --quiet or -q is specified. Add tests for --quiet.

---
 builtin/stash--helper.c | 55 +++++++++++++++++++++++++++--------------
 t/t3903-stash.sh        | 23 +++++++++++++++++
 2 files changed, 59 insertions(+), 19 deletions(-)
builtin/stash--helper.c +36 -19
index 23f1329637..befb944871 100644
@@ -973,7 +973,7 @@ static int save_untracked_files(struct stash_info *info, struct strbuf *msg,
 }
 
 static int stash_patch(struct stash_info *info, struct pathspec ps,
-		       struct strbuf *out_patch)
+		       struct strbuf *out_patch, int quiet)
 {
 	int ret = 0;
 	struct strbuf out = STRBUF_INIT;
@@ -1026,7 +1026,8 @@ static int stash_patch(struct stash_info *info, struct pathspec ps,
 	}
 
 	if (!out_patch->len) {
-		fprintf_ln(stderr, _("No changes selected"));
+		if (!quiet)
+			fprintf_ln(stderr, _("No changes selected"));
 		ret = 1;
 	}
 
@@ -1105,7 +1106,8 @@ static int stash_working_tree(struct stash_info *info, struct pathspec ps)
 
 static int do_create_stash(struct pathspec ps, char **stash_msg,
 			   int include_untracked, int patch_mode,
-			   struct stash_info *info, struct strbuf *patch)
+			   struct stash_info *info, struct strbuf *patch,
+			   int quiet)
 {
 	int ret = 0;
 	int flags = 0;
@@ -1124,7 +1126,9 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 	refresh_cache(REFRESH_QUIET);
 
 	if (get_oid("HEAD", &info->b_commit)) {
-		fprintf_ln(stderr, _("You do not have the initial commit yet"));
+		if (!quiet)
+			fprintf_ln(stderr, _("You do not have "
+					     "the initial commit yet"));
 		ret = -1;
 		*stash_msg = NULL;
 		goto done;
@@ -1151,7 +1155,9 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 	if (write_cache_as_tree(&info->i_tree, 0, NULL) ||
 	    commit_tree(commit_tree_label.buf, commit_tree_label.len,
 			&info->i_tree, parents, &info->i_commit, NULL, NULL)) {
-		fprintf_ln(stderr, _("Cannot save the current index state"));
+		if (!quiet)
+			fprintf_ln(stderr, _("Cannot save the current "
+					     "index state"));
 		ret = -1;
 		*stash_msg = NULL;
 		goto done;
@@ -1160,8 +1166,9 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 	if (include_untracked && get_untracked_files(ps, include_untracked,
 						     &untracked_files)) {
 		if (save_untracked_files(info, &msg, untracked_files)) {
-			fprintf_ln(stderr, _("Cannot save "
-					     "the untracked files"));
+			if (!quiet)
+				fprintf_ln(stderr, _("Cannot save "
+						     "the untracked files"));
 			ret = -1;
 			*stash_msg = NULL;
 			goto done;
@@ -1169,19 +1176,21 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 		untracked_commit_option = 1;
 	}
 	if (patch_mode) {
-		ret = stash_patch(info, ps, patch);
+		ret = stash_patch(info, ps, patch, quiet);
 		*stash_msg = NULL;
 		if (ret < 0) {
-			fprintf_ln(stderr, _("Cannot save the current "
-					     "worktree state"));
+			if (!quiet)
+				fprintf_ln(stderr, _("Cannot save the current "
+						     "worktree state"));
 			goto done;
 		} else if (ret > 0) {
 			goto done;
 		}
 	} else {
 		if (stash_working_tree(info, ps)) {
-			fprintf_ln(stderr, _("Cannot save the current "
-					     "worktree state"));
+			if (!quiet)
+				fprintf_ln(stderr, _("Cannot save the current "
+						     "worktree state"));
 			ret = -1;
 			*stash_msg = NULL;
 			goto done;
@@ -1210,7 +1219,9 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 
 	if (commit_tree(*stash_msg, strlen(*stash_msg), &info->w_tree,
 			parents, &info->w_commit, NULL, NULL)) {
-		fprintf_ln(stderr, _("Cannot record working tree state"));
+		if (!quiet)
+			fprintf_ln(stderr, _("Cannot record "
+					     "working tree state"));
 		ret = -1;
 		goto done;
 	}
@@ -1244,7 +1255,7 @@ static int create_stash(int argc, const char **argv, const char *prefix)
 
 	memset(&ps, 0, sizeof(ps));
 	ret = do_create_stash(ps, &stash_msg, include_untracked, 0, &info,
-			      NULL);
+			      NULL, 0);
 
 	if (!ret)
 		printf_ln("%s", oid_to_hex(&info.w_commit));
@@ -1306,23 +1317,27 @@ static int do_push_stash(struct pathspec ps, char *stash_msg, int quiet,
 
 	if (!reflog_exists(ref_stash) && do_clear_stash()) {
 		ret = -1;
-		fprintf_ln(stderr, _("Cannot initialize stash"));
+		if (!quiet)
+			fprintf_ln(stderr, _("Cannot initialize stash"));
 		goto done;
 	}
 
 	if (do_create_stash(ps, &stash_msg, include_untracked, patch_mode,
-			    &info, &patch)) {
+			    &info, &patch, quiet)) {
 		ret = -1;
 		goto done;
 	}
 
 	if (do_store_stash(&info.w_commit, stash_msg, 1)) {
 		ret = -1;
-		fprintf_ln(stderr, _("Cannot save the current status"));
+		if (!quiet)
+			fprintf_ln(stderr, _("Cannot save the current status"));
 		goto done;
 	}
 
-	printf_ln(_("Saved working directory and index state %s"), stash_msg);
+	if (!quiet)
+		printf_ln(_("Saved working directory and index state %s"),
+			  stash_msg);
 
 	if (!patch_mode) {
 		if (include_untracked && !ps.nr) {
@@ -1423,7 +1438,9 @@ static int do_push_stash(struct pathspec ps, char *stash_msg, int quiet,
 		argv_array_pushl(&cp.args, "apply", "-R", NULL);
 
 		if (pipe_command(&cp, patch.buf, patch.len, NULL, 0, NULL, 0)) {
-			fprintf_ln(stderr, _("Cannot remove worktree changes"));
+			if (!quiet)
+				fprintf_ln(stderr, _("Cannot remove "
+						     "worktree changes"));
 			ret = -1;
 			goto done;
 		}
t/t3903-stash.sh +23 -0
index 3114c7bc4c..ed4611d3d8 100755
@@ -1064,6 +1064,29 @@ test_expect_success 'push: <pathspec> not in the repository errors out' '
 	test_path_is_file untracked
 '
 
+test_expect_success 'push: -q is quiet with changes' '
+	>foo &&
+	git add foo &&
+	git stash push -q >output 2>&1 &&
+	test_must_be_empty output
+'
+
+test_expect_success 'push: -q is quiet with no changes' '
+	git stash push -q >output 2>&1 &&
+	test_must_be_empty output
+'
+
+test_expect_success 'push: -q is quiet even if there is no initial commit' '
+	git init foo_dir &&
+	test_when_finished rm -rf foo_dir &&
+	(
+		cd foo_dir &&
+		>bar &&
+		test_must_fail git stash push -q >output 2>&1 &&
+		test_must_be_empty output
+	)
+'
+
 test_expect_success 'untracked files are left in place when -u is not given' '
 	>file &&
 	git add file &&
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#21 lore raw

PATCH v10 18/21 stash: convert save to builtin

In reply to Paul-Sebastian Ungureanu

Add stash save to the helper and delete functions which are no longer needed (show_help(), save_stash(), push_stash(), create_stash(), clear_stash(), untracked_files() and no_changes()).

The -m option is no longer supported as it might not make sense to have two ways of passing a message. Even if this is a change in behaviour, the documentation remains the same because the -m parameter was omitted before.

---
 builtin/stash--helper.c |  52 +++++++
 git-stash.sh            | 311 +---------------------------------------
 2 files changed, 54 insertions(+), 309 deletions(-)
builtin/stash--helper.c +52 -0
index befb944871..a0413f5d00 100644
@@ -26,6 +26,8 @@ static const char * const git_stash_helper_usage[] = {
 	N_("git stash--helper [push [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]\n"
 	   "          [-u|--include-untracked] [-a|--all] [-m|--message <message>]\n"
 	   "          [--] [<pathspec>...]]"),
+	N_("git stash--helper save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]\n"
+	   "          [-u|--include-untracked] [-a|--all] [<message>]"),
 	NULL
 };
 
@@ -81,6 +83,12 @@ static const char * const git_stash_helper_push_usage[] = {
 	NULL
 };
 
+static const char * const git_stash_helper_save_usage[] = {
+	N_("git stash--helper save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]\n"
+	   "          [-u|--include-untracked] [-a|--all] [<message>]"),
+	NULL
+};
+
 static const char *ref_stash = "refs/stash";
 static struct strbuf stash_index_path = STRBUF_INIT;
 
@@ -1496,6 +1504,48 @@ static int push_stash(int argc, const char **argv, const char *prefix)
 			     keep_index, patch_mode, include_untracked);
 }
 
+static int save_stash(int argc, const char **argv, const char *prefix)
+{
+	int keep_index = -1;
+	int patch_mode = 0;
+	int include_untracked = 0;
+	int quiet = 0;
+	int ret = 0;
+	char *stash_msg = NULL;
+	struct pathspec ps;
+	struct strbuf buf = STRBUF_INIT;
+	struct option options[] = {
+		OPT_BOOL('k', "keep-index", &keep_index,
+			 N_("keep index")),
+		OPT_BOOL('p', "patch", &patch_mode,
+			 N_("stash in patch mode")),
+		OPT__QUIET(&quiet, N_("quiet mode")),
+		OPT_BOOL('u', "include-untracked", &include_untracked,
+			 N_("include untracked files in stash")),
+		OPT_SET_INT('a', "all", &include_untracked,
+			    N_("include ignore files"), 2),
+		OPT_STRING('m', "message", &stash_msg, "message",
+			   N_("stash message")),
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options,
+			     git_stash_helper_save_usage,
+			     PARSE_OPT_KEEP_DASHDASH);
+
+	if (argc) {
+		strbuf_join_argv(&buf, argc, argv, ' ');
+		stash_msg = buf.buf;
+	}
+
+	memset(&ps, 0, sizeof(ps));
+	ret = do_push_stash(ps, stash_msg, quiet, keep_index, patch_mode,
+			    include_untracked);
+
+	strbuf_release(&buf);
+	return ret;
+}
+
 int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 {
 	pid_t pid = getpid();
@@ -1536,6 +1586,8 @@ int cmd_stash__helper(int argc, const char **argv, const char *prefix)
 		return !!create_stash(argc, argv, prefix);
 	else if (!strcmp(argv[0], "push"))
 		return !!push_stash(argc, argv, prefix);
+	else if (!strcmp(argv[0], "save"))
+		return !!save_stash(argc, argv, prefix);
 
 	usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv[0]),
 		      git_stash_helper_usage, options);
git-stash.sh +2 -309

323 lines not on this page · raw message

Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#22 lore raw

Re: [PATCH v10 18/21] stash: convert save to builtin

Quoted 4 lines · Paul-Sebastian Ungureanu

The -m option is no longer supported as it might not make sense to have two ways of passing a message. Even if this is a change in behaviour, the documentation remains the same because the -m parameter was omitted before.

[...]

builtin/stash--helper.c static int push_stash(int argc, const char **argv, const char *prefix) · line 1529

Quoted 3 lines
builtin/stash--helper.c +3 -0
+		OPT_STRING('m', "message", &stash_msg, "message",
+			   N_("stash message")),
+		OPT_END()

We do seem to support a '-m' option here though. I'm happy not supporting it, but the commit message seems to say otherwise. I can't remember the discussion her, but either the commit message, or the option parsing should be updated here.

#23 lore raw

PATCH v10 19/21 stash: convert `stash--helper.c` into `stash.c`

In reply to Paul-Sebastian Ungureanu

The old shell script git-stash.sh was removed and replaced entirely by builtin/stash.c. In order to do that, create and push were adapted to work without stash.sh. For example, before this commit, git stash create called git stash--helper create --message "$*". If it called git stash--helper create "$@", then some of these changes wouldn't have been necessary.

This commit also removes the word helper since now stash is called directly and not by a shell script.

---
 .gitignore                           |   1 -
 Makefile                             |   3 +-
 builtin.h                            |   2 +-
 builtin/{stash--helper.c => stash.c} | 166 +++++++++++++++------------
 git-stash.sh                         | 153 ------------------------
 git.c                                |   2 +-
 6 files changed, 96 insertions(+), 231 deletions(-)
 rename builtin/{stash--helper.c => stash.c} (90%)
 delete mode 100755 git-stash.sh
.gitignore +0 -1
index b59661cb88..ffceea7d59 100644
@@ -157,7 +157,6 @@
 /git-show-ref
 /git-stage
 /git-stash
-/git-stash--helper
 /git-status
 /git-stripspace
 /git-submodule
Makefile +1 -2
index f900c68e69..ac1787d113 100644
@@ -617,7 +617,6 @@ SCRIPT_SH += git-quiltimport.sh
 SCRIPT_SH += git-rebase.sh
 SCRIPT_SH += git-remote-testgit.sh
 SCRIPT_SH += git-request-pull.sh
-SCRIPT_SH += git-stash.sh
 SCRIPT_SH += git-submodule.sh
 SCRIPT_SH += git-web--browse.sh
 
@@ -1093,7 +1092,7 @@ BUILTIN_OBJS += builtin/shortlog.o
 BUILTIN_OBJS += builtin/show-branch.o
 BUILTIN_OBJS += builtin/show-index.o
 BUILTIN_OBJS += builtin/show-ref.o
-BUILTIN_OBJS += builtin/stash--helper.o
+BUILTIN_OBJS += builtin/stash.o
 BUILTIN_OBJS += builtin/stripspace.o
 BUILTIN_OBJS += builtin/submodule--helper.o
 BUILTIN_OBJS += builtin/symbolic-ref.o
builtin.h +1 -1
index 317bc338f7..e60f0fc58f 100644
@@ -223,7 +223,7 @@ extern int cmd_show(int argc, const char **argv, const char *prefix);
 extern int cmd_show_branch(int argc, const char **argv, const char *prefix);
 extern int cmd_show_index(int argc, const char **argv, const char *prefix);
 extern int cmd_status(int argc, const char **argv, const char *prefix);
-extern int cmd_stash__helper(int argc, const char **argv, const char *prefix);
+extern int cmd_stash(int argc, const char **argv, const char *prefix);
 extern int cmd_stripspace(int argc, const char **argv, const char *prefix);
 extern int cmd_submodule__helper(int argc, const char **argv, const char *prefix);
 extern int cmd_symbolic_ref(int argc, const char **argv, const char *prefix);
builtin/stash.c renamed from builtin/stash--helper.c +93 -73

352 lines not on this page · raw message

git-stash.sh deleted +0 -153

153 lines not on this page · raw message

git.c +1 -1
index 3c0e762d7d..78548397cf 100644
@@ -544,7 +544,7 @@ static struct cmd_struct commands[] = {
 	{ "show-index", cmd_show_index },
 	{ "show-ref", cmd_show_ref, RUN_SETUP },
 	{ "stage", cmd_add, RUN_SETUP | NEED_WORK_TREE },
-	{ "stash--helper", cmd_stash__helper, RUN_SETUP | NEED_WORK_TREE },
+	{ "stash", cmd_stash, RUN_SETUP | NEED_WORK_TREE },
 	{ "status", cmd_status, RUN_SETUP | NEED_WORK_TREE },
 	{ "stripspace", cmd_stripspace },
 	{ "submodule--helper", cmd_submodule__helper, RUN_SETUP | SUPPORT_SUPER_PREFIX | NO_PARSEOPT },
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#24 lore raw

Re: [PATCH v10 19/21] stash: convert `stash--helper.c` into `stash.c`

Quoted 82 lines · Paul-Sebastian Ungureanu

The old shell script git-stash.sh was removed and replaced entirely by builtin/stash.c. In order to do that, create and push were adapted to work without stash.sh. For example, before this commit, git stash create called git stash--helper create --message "$*". If it called git stash--helper create "$@", then some of these changes wouldn't have been necessary.

This commit also removes the word helper since now stash is called directly and not by a shell script.

---

(quoted diff) +1 -13
@@ -1138,7 +1133,6 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 			fprintf_ln(stderr, _("You do not have "
 					     "the initial commit yet"));
 		ret = -1;
-		*stash_msg = NULL;
 		goto done;
 	} else {
 		head_commit = lookup_commit(the_repository, &info->b_commit);
@@ -1146,7 +1140,6 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 
 	if (!check_changes(ps, include_untracked)) {
 		ret = 1;
-		*stash_msg = NULL;
 		goto done;
 	}
 
@@ -1167,7 +1160,6 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 			fprintf_ln(stderr, _("Cannot save the current "
 					     "index state"));
 		ret = -1;
-		*stash_msg = NULL;
 		goto done;
 	}
 
@@ -1178,14 +1170,12 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 				fprintf_ln(stderr, _("Cannot save "
 						     "the untracked files"));
 			ret = -1;
-			*stash_msg = NULL;
 			goto done;
 		}
 		untracked_commit_option = 1;
 	}
 	if (patch_mode) {
 		ret = stash_patch(info, ps, patch, quiet);
-		*stash_msg = NULL;
 		if (ret < 0) {
 			if (!quiet)
 				fprintf_ln(stderr, _("Cannot save the current "
@@ -1200,7 +1190,6 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 				fprintf_ln(stderr, _("Cannot save the current "
 						     "worktree state"));
 			ret = -1;
-			*stash_msg = NULL;
 			goto done;
 		}
 	}
@@ -1210,7 +1199,7 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 	else
 		strbuf_addf(&stash_msg_buf, "On %s: %s", branch_name,
 			    *stash_msg);
-	*stash_msg = strbuf_detach(&stash_msg_buf, NULL);
+	*stash_msg = xstrdup(stash_msg_buf.buf);
 
 	/*
 	 * `parents` will be empty after calling `commit_tree()`, so there is
@@ -1244,30 +1233,23 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 
 static int create_stash(int argc, const char **argv, const char *prefix)
 {
-	int include_untracked = 0;
 	int ret = 0;
 	char *stash_msg = NULL;
 	struct stash_info info;
 	struct pathspec ps;
-	struct option options[] = {
-		OPT_BOOL('u', "include-untracked", &include_untracked,
-			 N_("include untracked files in stash")),
-		OPT_STRING('m', "message", &stash_msg, N_("message"),
-			 N_("stash message")),

Review static int do_create_stash(struct pathspec ps, char **stash_msg, · line 1244

Quoted 10 lines
(quoted diff) +4 -5
-		OPT_END()
-	};
+	struct strbuf stash_msg_buf = STRBUF_INIT;
 
-	argc = parse_options(argc, argv, prefix, options,
-			     git_stash_helper_create_usage,
-			     0);
+	/* Starting with argv[1], since argv[0] is "create" */
+	strbuf_join_argv(&stash_msg_buf, argc - 1, ++argv, ' ');
+	stash_msg = stash_msg_buf.buf;

stash_msg is just a pointer to stash_msg_buf.buf here..

Review static int do_create_stash(struct pathspec ps, char **stash_msg, · line 1251

Quoted 10 lines
(quoted diff) +2 -2
 	memset(&ps, 0, sizeof(ps));
-	ret = do_create_stash(ps, &stash_msg, include_untracked, 0, &info,
-			      NULL, 0);
+	ret = do_create_stash(ps, &stash_msg, 0, 0, &info, NULL, 0);
 
 	if (!ret)
 		printf_ln("%s", oid_to_hex(&info.w_commit));
 
+	strbuf_release(&stash_msg_buf);

We release the strbuf here, which means stash_msg_buf.buf is now 'strbuf_slopbuf', which is a global variable and can't be free'd. If stash_msg is not changed within do_create_stash, it is now pointing to 'strbuf_slopbuf', and we try to free that below, which makes git crash in t3903.44, which breaks bisection.

Review static int do_create_stash(struct pathspec ps, char **stash_msg, · line 1254

Quoted 3 lines
(quoted diff) +0 -0
 	free(stash_msg);
 
 	/*

I think the following diff fixes memory management, by making do_push_stash responsible for freeing stash_msg when it's done with it, while the callers of do_create_stash have to free the parameter they pass in (although it may be pointing to something different than what was passed in).

builtin/stash.c +3 -2
index e945c13c42..3b50f4bd53 100644
@@ -1199,6 +1199,7 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 	else
 		strbuf_addf(&stash_msg_buf, "On %s: %s", branch_name,
 			    *stash_msg);
+	free(*stash_msg);
 	*stash_msg = xstrdup(stash_msg_buf.buf);
 
 	/*
@@ -1241,7 +1242,7 @@ static int create_stash(int argc, const char **argv, const char *prefix)
 
 	/* Starting with argv[1], since argv[0] is "create" */
 	strbuf_join_argv(&stash_msg_buf, argc - 1, ++argv, ' ');
-	stash_msg = stash_msg_buf.buf;
+	stash_msg = xstrdup(stash_msg_buf.buf);
 
 	memset(&ps, 0, sizeof(ps));
 	ret = do_create_stash(ps, &stash_msg, 0, 0, &info, NULL, 0);
@@ -1522,7 +1523,7 @@ static int save_stash(int argc, const char **argv, const char *prefix)
 	}
 
 	memset(&ps, 0, sizeof(ps));
-	ret = do_push_stash(ps, stash_msg, quiet, keep_index, patch_mode,
+	ret = do_push_stash(ps, xstrdup_or_null(stash_msg), quiet, keep_index, patch_mode,
 			    include_untracked);
 
 	strbuf_release(&buf);

The above, as well as the some of the changes I quoted above should probably be squashed in to the relevant patches, rather than being part of this patch ("stash: convert create to builtin", and "stash:
convert save to builtin").

#25 lore raw

PATCH v10 20/21 stash: optimize `get_untracked_files()` and `check_changes()`

In reply to Paul-Sebastian Ungureanu

This commits introduces a optimization by avoiding calling the same functions again. For example, git stash push -u would call at some points the following functions:

* check_changes() (inside do_push_stash())
* do_create_stash(), which calls: check_changes() and
get_untracked_files()

Note that check_changes() also calls get_untracked_files(). So, check_changes() is called 2 times and get_untracked_files() 3 times.

The old function check_changes() now consists of two functions:
get_untracked_files() and check_changes_tracked_files().

These are the call chains for push and create:

* push_stash() -> do_push_stash() -> do_create_stash()

* create_stash() -> do_create_stash()

To prevent calling the same functions over and over again, check_changes() inside do_create_stash() is now placed in the caller functions (create_stash() and do_push_stash()). This way check_changes() and get_untracked files() are called only one time.

https://public-inbox.org/git/[email protected]/

---
 builtin/stash.c | 50 ++++++++++++++++++++++++++++---------------------
 1 file changed, 29 insertions(+), 21 deletions(-)
builtin/stash.c +29 -21
index e945c13c42..d2365ada2e 100644
@@ -881,18 +881,18 @@ static int get_untracked_files(struct pathspec ps, int include_untracked,
 }
 
 /*
- * The return value of `check_changes()` can be:
+ * The return value of `check_changes_tracked_files()` can be:
  *
  * < 0 if there was an error
  * = 0 if there are no changes.
  * > 0 if there are changes.
  */
-static int check_changes(struct pathspec ps, int include_untracked)
+
+static int check_changes_tracked_files(struct pathspec ps)
 {
 	int result;
 	struct rev_info rev;
 	struct object_id dummy;
-	struct strbuf out = STRBUF_INIT;
 
 	/* No initial commit. */
 	if (get_oid("HEAD", &dummy))
@@ -920,14 +920,26 @@ static int check_changes(struct pathspec ps, int include_untracked)
 	if (diff_result_code(&rev.diffopt, result))
 		return 1;
 
+	return 0;
+}
+
+/*
+ * The function will fill `untracked_files` with the names of untracked files
+ * It will return 1 if there were any changes and 0 if there were not.
+ */
+
+static int check_changes(struct pathspec ps, int include_untracked,
+			 struct strbuf *untracked_files)
+{
+	int ret = 0;
+	if (check_changes_tracked_files(ps))
+		ret = 1;
+
 	if (include_untracked && get_untracked_files(ps, include_untracked,
-						     &out)) {
-		strbuf_release(&out);
-		return 1;
-	}
+						     untracked_files))
+		ret = 1;
 
-	strbuf_release(&out);
-	return 0;
+	return ret;
 }
 
 static int save_untracked_files(struct stash_info *info, struct strbuf *msg,
@@ -1138,7 +1150,7 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 		head_commit = lookup_commit(the_repository, &info->b_commit);
 	}
 
-	if (!check_changes(ps, include_untracked)) {
+	if (!check_changes(ps, include_untracked, &untracked_files)) {
 		ret = 1;
 		goto done;
 	}
@@ -1163,8 +1175,7 @@ static int do_create_stash(struct pathspec ps, char **stash_msg,
 		goto done;
 	}
 
-	if (include_untracked && get_untracked_files(ps, include_untracked,
-						     &untracked_files)) {
+	if (include_untracked) {
 		if (save_untracked_files(info, &msg, untracked_files)) {
 			if (!quiet)
 				fprintf_ln(stderr, _("Cannot save "
@@ -1244,19 +1255,15 @@ static int create_stash(int argc, const char **argv, const char *prefix)
 	stash_msg = stash_msg_buf.buf;
 
 	memset(&ps, 0, sizeof(ps));
-	ret = do_create_stash(ps, &stash_msg, 0, 0, &info, NULL, 0);
+	if (!check_changes_tracked_files(ps))
+		return 0;
 
-	if (!ret)
+	if (!(ret = do_create_stash(ps, &stash_msg, 0, 0, &info, NULL, 0)))
 		printf_ln("%s", oid_to_hex(&info.w_commit));
 
 	strbuf_release(&stash_msg_buf);
 	free(stash_msg);
-
-	/*
-	 * ret can be 1 if there were no changes. In this case, we should
-	 * not error out.
-	 */
-	return ret < 0;
+	return ret;
 }
 
 static int do_push_stash(struct pathspec ps, char *stash_msg, int quiet,
@@ -1265,6 +1272,7 @@ static int do_push_stash(struct pathspec ps, char *stash_msg, int quiet,
 	int ret = 0;
 	struct stash_info info;
 	struct strbuf patch = STRBUF_INIT;
+	struct strbuf untracked_files = STRBUF_INIT;
 
 	if (patch_mode && keep_index == -1)
 		keep_index = 1;
@@ -1299,7 +1307,7 @@ static int do_push_stash(struct pathspec ps, char *stash_msg, int quiet,
 		goto done;
 	}
 
-	if (!check_changes(ps, include_untracked)) {
+	if (!check_changes(ps, include_untracked, &untracked_files)) {
 		if (!quiet)
 			printf_ln(_("No local changes to save"));
 		goto done;
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#26 lore raw

PATCH v10 21/21 stash: replace all `write-tree` child processes with API calls

In reply to Paul-Sebastian Ungureanu

This commit replaces spawning git write-tree with API calls.

---
 builtin/stash.c | 41 ++++++++++++-----------------------------
 1 file changed, 12 insertions(+), 29 deletions(-)
builtin/stash.c +12 -29
index d2365ada2e..651d05c820 100644
@@ -947,9 +947,8 @@ static int save_untracked_files(struct stash_info *info, struct strbuf *msg,
 {
 	int ret = 0;
 	struct strbuf untracked_msg = STRBUF_INIT;
-	struct strbuf out = STRBUF_INIT;
 	struct child_process cp_upd_index = CHILD_PROCESS_INIT;
-	struct child_process cp_write_tree = CHILD_PROCESS_INIT;
+	struct index_state istate = { NULL };
 
 	cp_upd_index.git_cmd = 1;
 	argv_array_pushl(&cp_upd_index.args, "update-index", "-z", "--add",
@@ -964,15 +963,11 @@ static int save_untracked_files(struct stash_info *info, struct strbuf *msg,
 		goto done;
 	}
 
-	cp_write_tree.git_cmd = 1;
-	argv_array_push(&cp_write_tree.args, "write-tree");
-	argv_array_pushf(&cp_write_tree.env_array, "GIT_INDEX_FILE=%s",
-			 stash_index_path.buf);
-	if (pipe_command(&cp_write_tree, NULL, 0, &out, 0,NULL, 0)) {
+	if (write_index_as_tree(&info->u_tree, &istate, stash_index_path.buf, 0,
+				NULL)) {
 		ret = -1;
 		goto done;
 	}
-	get_oid_hex(out.buf, &info->u_tree);
 
 	if (commit_tree(untracked_msg.buf, untracked_msg.len,
 			&info->u_tree, NULL, &info->u_commit, NULL, NULL)) {
@@ -981,8 +976,8 @@ static int save_untracked_files(struct stash_info *info, struct strbuf *msg,
 	}
 
 done:
+	discard_index(&istate);
 	strbuf_release(&untracked_msg);
-	strbuf_release(&out);
 	remove_path(stash_index_path.buf);
 	return ret;
 }
@@ -991,11 +986,10 @@ static int stash_patch(struct stash_info *info, struct pathspec ps,
 		       struct strbuf *out_patch, int quiet)
 {
 	int ret = 0;
-	struct strbuf out = STRBUF_INIT;
 	struct child_process cp_read_tree = CHILD_PROCESS_INIT;
 	struct child_process cp_add_i = CHILD_PROCESS_INIT;
-	struct child_process cp_write_tree = CHILD_PROCESS_INIT;
 	struct child_process cp_diff_tree = CHILD_PROCESS_INIT;
+	struct index_state istate = { NULL };
 
 	remove_path(stash_index_path.buf);
 
@@ -1021,17 +1015,12 @@ static int stash_patch(struct stash_info *info, struct pathspec ps,
 	}
 
 	/* State of the working tree. */
-	cp_write_tree.git_cmd = 1;
-	argv_array_push(&cp_write_tree.args, "write-tree");
-	argv_array_pushf(&cp_write_tree.env_array, "GIT_INDEX_FILE=%s",
-			 stash_index_path.buf);
-	if (pipe_command(&cp_write_tree, NULL, 0, &out, 0,NULL, 0)) {
+	if (write_index_as_tree(&info->w_tree, &istate, stash_index_path.buf, 0,
+				NULL)) {
 		ret = -1;
 		goto done;
 	}
 
-	get_oid_hex(out.buf, &info->w_tree);
-
 	cp_diff_tree.git_cmd = 1;
 	argv_array_pushl(&cp_diff_tree.args, "diff-tree", "-p", "HEAD",
 			 oid_to_hex(&info->w_tree), "--", NULL);
@@ -1047,7 +1036,7 @@ static int stash_patch(struct stash_info *info, struct pathspec ps,
 	}
 
 done:
-	strbuf_release(&out);
+	discard_index(&istate);
 	remove_path(stash_index_path.buf);
 	return ret;
 }
@@ -1057,9 +1046,8 @@ static int stash_working_tree(struct stash_info *info, struct pathspec ps)
 	int ret = 0;
 	struct rev_info rev;
 	struct child_process cp_upd_index = CHILD_PROCESS_INIT;
-	struct child_process cp_write_tree = CHILD_PROCESS_INIT;
-	struct strbuf out = STRBUF_INIT;
 	struct strbuf diff_output = STRBUF_INIT;
+	struct index_state istate = { NULL };
 
 	set_alternate_index_output(stash_index_path.buf);
 	if (reset_tree(&info->i_tree, 0, 0)) {
@@ -1099,20 +1087,15 @@ static int stash_working_tree(struct stash_info *info, struct pathspec ps)
 		goto done;
 	}
 
-	cp_write_tree.git_cmd = 1;
-	argv_array_push(&cp_write_tree.args, "write-tree");
-	argv_array_pushf(&cp_write_tree.env_array, "GIT_INDEX_FILE=%s",
-			 stash_index_path.buf);
-	if (pipe_command(&cp_write_tree, NULL, 0, &out, 0,NULL, 0)) {
+	if (write_index_as_tree(&info->w_tree, &istate, stash_index_path.buf, 0,
+				NULL)) {
 		ret = -1;
 		goto done;
 	}
 
-	get_oid_hex(out.buf, &info->w_tree);
-
 done:
+	discard_index(&istate);
 	UNLEAK(rev);
-	strbuf_release(&out);
 	object_array_clear(&rev.pending);
 	strbuf_release(&diff_output);
 	remove_path(stash_index_path.buf);
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#27 lore raw

Re: [PATCH v10 00/21] Convert "git stash" to C builtin

In reply to Paul-Sebastian Ungureanu
Quoted 7 lines · Paul-Sebastian Ungureanu

Hello,

This is a new iteration of git stash, based on the last review. This iteration fixes some code styling issues, bring some changes to do_push_stash() and do_create_stash() to be closer to API by following Thomas Gummerer's review of last iteration [1]. Also, there were some missing messages [2], which are now included.

Thanks for your work! I had two more comments (on the patches inline). Once those are addressed, I'd be happy for this to be merged to 'next'.

Since I applied this locally, and it may help someone else who may want to have a look at this, the range-diff is below:

 1:  b7224e494e =  1:  89142f99e7 sha1-name.c: add `get_oidf()` which acts like `get_oid()`
 2:  63f2e0e6f9 !  2:  2d45985676 strbuf.c: add `strbuf_join_argv()`
    @@ -14,19 +14,17 @@
      	strbuf_setlen(sb, sb->len + sb2->len);
      }
      
    -+const char *strbuf_join_argv(struct strbuf *buf,
    -+			     int argc, const char **argv, char delim)
    ++void strbuf_join_argv(struct strbuf *buf,
    ++		      int argc, const char **argv, char delim)
     +{
     +	if (!argc)
    -+		return buf->buf;
    ++		return;
     +
     +	strbuf_addstr(buf, *argv);
     +	while (--argc) {
     +		strbuf_addch(buf, delim);
     +		strbuf_addstr(buf, *(++argv));
     +	}
    -+
    -+	return buf->buf;
     +}
     +
      void strbuf_addchars(struct strbuf *sb, int c, size_t n)
    @@ -40,12 +38,12 @@
       */
      extern void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2);
      
    -+
     +/**
    -+ *
    ++ * Join the arguments into a buffer. `delim` is put between every
    ++ * two arguments.
     + */
    -+extern const char *strbuf_join_argv(struct strbuf *buf, int argc,
    -+				    const char **argv, char delim);
    ++extern void strbuf_join_argv(struct strbuf *buf, int argc,
    ++			     const char **argv, char delim);
     +
      /**
       * This function can be used to expand a format string containing
 3:  9b9433781b =  3:  63d10ee599 stash: improve option parsing test coverage
 4:  c1d38060c5 !  4:  a6953b57e5 stash: update test cases conform to coding guidelines

@@ -1,8 +1,9 @@
Author: Paul-Sebastian Ungureanu <[email protected]>

- stash: update test cases conform to coding guidelines
+ t3903: modernize style

- Removed whitespaces after redirection operators.
+ Remove whitespaces after redirection operators and wrap
+ long lines.

 5:  ac7a8267e6 =  5:  9985d8650b stash: rename test cases to be more descriptive
 6:  0e6458a280 =  6:  93d7e82b96 stash: add tests for `git stash show` config
13:  6e04c948cf !  7:  e06aca5ff5 stash: mention options in `show` synopsis.

@@ -1,9 +1,9 @@
Author: Paul-Sebastian Ungureanu <[email protected]>

- stash: mention options in show synopsis.
+ stash: mention options in show synopsis

- Mention in the usage text and in the documentation, that show
- accepts any option known to git diff.
+ Mention in the documentation, that show accepts any
+ option known to git diff.

@@ -28,25 +28,3 @@

Show the changes recorded in the stash entry as a diff between the stashed contents and the commit back when the stash entry was first
-
- diff --git a/builtin/stash--helper.c b/builtin/stash--helper.c
- --- a/builtin/stash--helper.c
- +++ b/builtin/stash--helper.c
-@@
-
- static const char * const git_stash_helper_usage[] = {
- N_("git stash--helper list [<options>]"),
-- N_("git stash--helper show [<stash>]"),
-+ N_("git stash--helper show [<options>] [<stash>]"),
- N_("git stash--helper drop [-q|--quiet] [<stash>]"),
- N_("git stash--helper ( pop | apply ) [--index] [-q|--quiet] [<stash>]"),
- N_("git stash--helper branch <branchname> [<stash>]"),
-@@
- };
-
- static const char * const git_stash_helper_show_usage[] = {
-- N_("git stash--helper show [<stash>]"),
-+ N_("git stash--helper show [<options>] [<stash>]"),
- NULL
- };
-
7: a2abd1b4bd ! 8: 974dbaa492 stash: convert apply to builtin

    @@ -121,8 +121,8 @@
     +	    get_oidf(&info->w_tree, "%s:", revision) ||
     +	    get_oidf(&info->b_tree, "%s^1:", revision) ||
     +	    get_oidf(&info->i_tree, "%s^2:", revision)) {
    -+		free_stash_info(info);
     +		error(_("'%s' is not a stash-like commit"), revision);
    ++		free_stash_info(info);
     +		exit(128);
     +	}
     +}
    @@ -370,18 +370,20 @@
     +
     +			if (diff_tree_binary(&out, &info->w_commit)) {
     +				strbuf_release(&out);
    -+				return -1;
    ++				return error(_("Could not generate diff %s^!."),
    ++					     oid_to_hex(&info->w_commit));
     +			}
     +
     +			ret = apply_cached(&out);
     +			strbuf_release(&out);
     +			if (ret)
    -+				return -1;
    ++				return error(_("Conflicts in index."
    ++					       "Try without --index."));
     +
     +			discard_cache();
     +			read_cache();
     +			if (write_cache_as_tree(&index_tree, 0, NULL))
    -+				return -1;
    ++				return error(_("Could not save index tree"));
     +
     +			reset_head();
     +		}
 8:  b4e019e15e !  9:  70b09f7dbb stash: convert drop and clear to builtin
    @@ -68,7 +68,8 @@
     +			     PARSE_OPT_STOP_AT_NON_OPTION);
     +
     +	if (argc)
    -+		return error(_("git stash clear with parameters is unimplemented"));
    ++		return error(_("git stash clear with parameters is "
    ++			       "unimplemented"));
     +
     +	return do_clear_stash();
     +}
 9:  c097f4fb0c ! 10:  2408fb2f39 stash: convert branch to builtin
    @@ -53,7 +53,7 @@
     +			     git_stash_helper_branch_usage, 0);
     +
     +	if (!argc) {
    -+		fprintf_ln(stderr, "No branch name specified");
    ++		fprintf_ln(stderr, _("No branch name specified"));
     +		return -1;
     +	}
     +
10:  ed3c5ccfe8 ! 11:  b9d2ed6394 stash: convert pop to builtin
    @@ -58,7 +58,8 @@
     +
     +	assert_stash_ref(&info);
     +	if ((ret = do_apply_stash(prefix, &info, index, quiet)))
    -+		printf_ln(_("The stash entry is kept in case you need it again."));
    ++		printf_ln(_("The stash entry is kept in case "
    ++			    "you need it again."));
     +	else
     +		ret = do_drop_stash(prefix, &info, quiet);
     +
11:  85c0e246c6 = 12:  32375ffef9 stash: convert list to builtin
12:  c7425be617 ! 13:  738b3e25fc stash: convert show to builtin
    @@ -24,7 +24,7 @@
      
      static const char * const git_stash_helper_usage[] = {
      	N_("git stash--helper list [<options>]"),
    -+	N_("git stash--helper show [<stash>]"),
    ++	N_("git stash--helper show [<options>] [<stash>]"),
      	N_("git stash--helper drop [-q|--quiet] [<stash>]"),
      	N_("git stash--helper ( pop | apply ) [--index] [-q|--quiet] [<stash>]"),
      	N_("git stash--helper branch <branchname> [<stash>]"),
    @@ -33,7 +33,7 @@
      };
      
     +static const char * const git_stash_helper_show_usage[] = {
    -+	N_("git stash--helper show [<stash>]"),
    ++	N_("git stash--helper show [<options>] [<stash>]"),
     +	NULL
     +};
     +
14:  b661dba53c ! 14:  89add3b71a stash: convert store to builtin
    @@ -54,7 +54,8 @@
     +	struct object_context dummy;
     +	struct option options[] = {
     +		OPT__QUIET(&quiet, N_("be quiet")),
    -+		OPT_STRING('m', "message", &stash_msg, "message", N_("stash message")),
    ++		OPT_STRING('m', "message", &stash_msg, "message",
    ++			   N_("stash message")),
     +		OPT_END()
     +	};
     +
    @@ -64,7 +65,8 @@
     +
     +	if (argc != 1) {
     +		if (!quiet)
    -+			fprintf_ln(stderr, _("\"git stash store\" requires one <commit> argument"));
    ++			fprintf_ln(stderr, _("\"git stash store\" requires one "
    ++					     "<commit> argument"));
     +		return -1;
     +	}
     +
15:  bd827be103 ! 15:  989db67e9a stash: convert create to builtin
    @@ -49,7 +49,7 @@
     +		 * is because we will pass the output further to
     +		 * "git update-index -z ...".
     +		 */
    -+		strbuf_addch(data, 0);
    ++		strbuf_addch(data, '\0');
     +	}
     +}
     +
    @@ -61,7 +61,7 @@
      }
      
     +static void add_pathspecs(struct argv_array *args,
    -+				       struct pathspec ps) {
    ++			  struct pathspec ps) {
     +	int i;
     +
     +	for (i = 0; i < ps.nr; i++)
    @@ -119,7 +119,6 @@
     +static int check_changes(struct pathspec ps, int include_untracked)
     +{
     +	int result;
    -+	int ret = 0;
     +	struct rev_info rev;
     +	struct object_id dummy;
     +	struct strbuf out = STRBUF_INIT;
    @@ -176,7 +175,8 @@
     +			 stash_index_path.buf);
     +
     +	strbuf_addf(&untracked_msg, "untracked files on %s\n", msg->buf);
    -+	if (pipe_command(&cp_upd_index, files.buf, files.len, NULL, 0, NULL, 0)) {
    ++	if (pipe_command(&cp_upd_index, files.buf, files.len, NULL, 0,
    ++			 NULL, 0)) {
     +		ret = -1;
     +		goto done;
     +	}
    @@ -296,7 +296,8 @@
     +		goto done;
     +	}
     +
    -+	add_pending_object(&rev, parse_object(the_repository, &info->b_commit), "");
    ++	add_pending_object(&rev, parse_object(the_repository, &info->b_commit),
    ++			   "");
     +	if (run_diff_index(&rev, 0)) {
     +		ret = -1;
     +		goto done;
    @@ -392,7 +393,8 @@
     +	if (include_untracked && get_untracked_files(ps, include_untracked,
     +						     &untracked_files)) {
     +		if (save_untracked_files(info, &msg, untracked_files)) {
    -+			fprintf_ln(stderr, _("Cannot save the untracked files"));
    ++			fprintf_ln(stderr, _("Cannot save "
    ++					     "the untracked files"));
     +			ret = -1;
     +			*stash_msg = NULL;
     +			goto done;
    @@ -403,14 +405,16 @@
     +		ret = stash_patch(info, ps, &patch);
     +		*stash_msg = NULL;
     +		if (ret < 0) {
    -+			fprintf_ln(stderr, _("Cannot save the current worktree state"));
    ++			fprintf_ln(stderr, _("Cannot save the current "
    ++					     "worktree state"));
     +			goto done;
     +		} else if (ret > 0) {
     +			goto done;
     +		}
     +	} else {
     +		if (stash_working_tree(info, ps)) {
    -+			fprintf_ln(stderr, _("Cannot save the current worktree state"));
    ++			fprintf_ln(stderr, _("Cannot save the current "
    ++					     "worktree state"));
     +			ret = -1;
     +			*stash_msg = NULL;
     +			goto done;
    @@ -430,8 +434,11 @@
     +	 */
     +	parents = NULL;
     +	if (untracked_commit_option)
    -+		commit_list_insert(lookup_commit(the_repository, &info->u_commit), &parents);
    -+	commit_list_insert(lookup_commit(the_repository, &info->i_commit), &parents);
    ++		commit_list_insert(lookup_commit(the_repository,
    ++						 &info->u_commit),
    ++				   &parents);
    ++	commit_list_insert(lookup_commit(the_repository, &info->i_commit),
    ++			   &parents);
     +	commit_list_insert(head_commit, &parents);
     +
     +	if (commit_tree(*stash_msg, strlen(*stash_msg), &info->w_tree,
    @@ -474,11 +481,12 @@
     +	if (!ret)
     +		printf_ln("%s", oid_to_hex(&info.w_commit));
     +
    ++	free(stash_msg);
    ++
     +	/*
     +	 * ret can be 1 if there were no changes. In this case, we should
     +	 * not error out.
     +	 */
    -+	free((char *) stash_msg);
     +	return ret < 0;
     +}
     +
16:  e8434e36aa ! 16:  474e72d365 stash: convert push to builtin
    @@ -58,7 +58,7 @@
     +		ret = stash_patch(info, ps, patch);
      		*stash_msg = NULL;
      		if (ret < 0) {
    - 			fprintf_ln(stderr, _("Cannot save the current worktree state"));
    + 			fprintf_ln(stderr, _("Cannot save the current "
     @@
      			     0);
      
    @@ -101,28 +101,25 @@
     +
     +		if (report_path_error(ps_matched, &ps, NULL)) {
     +			fprintf_ln(stderr, _("Did you forget to 'git add'?"));
    -+			stash_msg = NULL;
     +			ret = -1;
    ++			free(ps_matched);
     +			goto done;
     +		}
     +		free(ps_matched);
     +	}
     +
     +	if (refresh_cache(REFRESH_QUIET)) {
    -+		stash_msg = NULL;
     +		ret = -1;
     +		goto done;
     +	}
     +
     +	if (!check_changes(ps, include_untracked)) {
    -+		stash_msg = NULL;
     +		if (!quiet)
     +			printf_ln(_("No local changes to save"));
     +		goto done;
     +	}
     +
     +	if (!reflog_exists(ref_stash) && do_clear_stash()) {
    -+		stash_msg = NULL;
     +		ret = -1;
     +		fprintf_ln(stderr, _("Cannot initialize stash"));
     +		goto done;
    @@ -293,8 +290,8 @@
     +			     0);
     +
     +	parse_pathspec(&ps, 0, PATHSPEC_PREFER_FULL, prefix, argv);
    -+	return do_push_stash(ps, stash_msg, quiet, keep_index, patch_mode,
    -+			     include_untracked);
    ++	return do_push_stash(ps, xstrdup_or_null(stash_msg), quiet,
    ++			     keep_index, patch_mode, include_untracked);
     +}
     +
      int cmd_stash__helper(int argc, const char **argv, const char *prefix)
17:  5a79bcaebf ! 17:  f6af86e944 stash: make push -q quiet
    @@ -5,7 +5,7 @@
         There is a change in behaviour with this commit. When there was
         no initial commit, the shell version of stash would still display
         a message. This commit makes `push` to not display any message if
    -    `--quiet` or `-q` is specified.
    +    `--quiet` or `-q` is specified. Add tests for `--quiet`.
     
         Signed-off-by: Paul-Sebastian Ungureanu <[email protected]>
     
    @@ -47,7 +47,8 @@
      	if (get_oid("HEAD", &info->b_commit)) {
     -		fprintf_ln(stderr, _("You do not have the initial commit yet"));
     +		if (!quiet)
    -+			fprintf_ln(stderr, _("You do not have the initial commit yet"));
    ++			fprintf_ln(stderr, _("You do not have "
    ++					     "the initial commit yet"));
      		ret = -1;
      		*stash_msg = NULL;
      		goto done;
    @@ -57,7 +58,8 @@
      			&info->i_tree, parents, &info->i_commit, NULL, NULL)) {
     -		fprintf_ln(stderr, _("Cannot save the current index state"));
     +		if (!quiet)
    -+			fprintf_ln(stderr, _("Cannot save the current index state"));
    ++			fprintf_ln(stderr, _("Cannot save the current "
    ++					     "index state"));
      		ret = -1;
      		*stash_msg = NULL;
      		goto done;
    @@ -65,9 +67,11 @@
      	if (include_untracked && get_untracked_files(ps, include_untracked,
      						     &untracked_files)) {
      		if (save_untracked_files(info, &msg, untracked_files)) {
    --			fprintf_ln(stderr, _("Cannot save the untracked files"));
    +-			fprintf_ln(stderr, _("Cannot save "
    +-					     "the untracked files"));
     +			if (!quiet)
    -+				fprintf_ln(stderr, _("Cannot save the untracked files"));
    ++				fprintf_ln(stderr, _("Cannot save "
    ++						     "the untracked files"));
      			ret = -1;
      			*stash_msg = NULL;
      			goto done;
    @@ -79,18 +83,22 @@
     +		ret = stash_patch(info, ps, patch, quiet);
      		*stash_msg = NULL;
      		if (ret < 0) {
    --			fprintf_ln(stderr, _("Cannot save the current worktree state"));
    +-			fprintf_ln(stderr, _("Cannot save the current "
    +-					     "worktree state"));
     +			if (!quiet)
    -+				fprintf_ln(stderr, _("Cannot save the current worktree state"));
    ++				fprintf_ln(stderr, _("Cannot save the current "
    ++						     "worktree state"));
      			goto done;
      		} else if (ret > 0) {
      			goto done;
      		}
      	} else {
      		if (stash_working_tree(info, ps)) {
    --			fprintf_ln(stderr, _("Cannot save the current worktree state"));
    +-			fprintf_ln(stderr, _("Cannot save the current "
    +-					     "worktree state"));
     +			if (!quiet)
    -+				fprintf_ln(stderr, _("Cannot save the current worktree state"));
    ++				fprintf_ln(stderr, _("Cannot save the current "
    ++						     "worktree state"));
      			ret = -1;
      			*stash_msg = NULL;
      			goto done;
    @@ -100,7 +108,8 @@
      			parents, &info->w_commit, NULL, NULL)) {
     -		fprintf_ln(stderr, _("Cannot record working tree state"));
     +		if (!quiet)
    -+			fprintf_ln(stderr, _("Cannot record working tree state"));
    ++			fprintf_ln(stderr, _("Cannot record "
    ++					     "working tree state"));
      		ret = -1;
      		goto done;
      	}
    @@ -114,8 +123,8 @@
      	if (!ret)
      		printf_ln("%s", oid_to_hex(&info.w_commit));
     @@
    + 
      	if (!reflog_exists(ref_stash) && do_clear_stash()) {
    - 		stash_msg = NULL;
      		ret = -1;
     -		fprintf_ln(stderr, _("Cannot initialize stash"));
     +		if (!quiet)
    @@ -151,7 +160,8 @@
      		if (pipe_command(&cp, patch.buf, patch.len, NULL, 0, NULL, 0)) {
     -			fprintf_ln(stderr, _("Cannot remove worktree changes"));
     +			if (!quiet)
    -+				fprintf_ln(stderr, _("Cannot remove worktree changes"));
    ++				fprintf_ln(stderr, _("Cannot remove "
    ++						     "worktree changes"));
      			ret = -1;
      			goto done;
      		}
18:  1c501ad666 ! 18:  c90e30173a stash: convert save to builtin
    @@ -40,7 +40,7 @@
      static struct strbuf stash_index_path = STRBUF_INIT;
      
     @@
    - 			     include_untracked);
    + 			     keep_index, patch_mode, include_untracked);
      }
      
     +static int save_stash(int argc, const char **argv, const char *prefix)
    @@ -72,8 +72,10 @@
     +			     git_stash_helper_save_usage,
     +			     PARSE_OPT_KEEP_DASHDASH);
     +
    -+	if (argc)
    -+		stash_msg = (char*) strbuf_join_argv(&buf, argc, argv, ' ');
    ++	if (argc) {
    ++		strbuf_join_argv(&buf, argc, argv, ' ');
    ++		stash_msg = buf.buf;
    ++	}
     +
     +	memset(&ps, 0, sizeof(ps));
     +	ret = do_push_stash(ps, stash_msg, quiet, keep_index, patch_mode,
19:  c4401b21db ! 19:  4360ea875d stash: convert `stash--helper.c` into `stash.c`
    @@ -215,7 +215,7 @@
     +			     git_stash_branch_usage, 0);
      
      	if (!argc) {
    - 		fprintf_ln(stderr, "No branch name specified");
    + 		fprintf_ln(stderr, _("No branch name specified"));
     @@
      	};
      
    @@ -244,6 +244,62 @@
      
      	if (argc != 1) {
     @@
    + 			fprintf_ln(stderr, _("You do not have "
    + 					     "the initial commit yet"));
    + 		ret = -1;
    +-		*stash_msg = NULL;
    + 		goto done;
    + 	} else {
    + 		head_commit = lookup_commit(the_repository, &info->b_commit);
    +@@
    + 
    + 	if (!check_changes(ps, include_untracked)) {
    + 		ret = 1;
    +-		*stash_msg = NULL;
    + 		goto done;
    + 	}
    + 
    +@@
    + 			fprintf_ln(stderr, _("Cannot save the current "
    + 					     "index state"));
    + 		ret = -1;
    +-		*stash_msg = NULL;
    + 		goto done;
    + 	}
    + 
    +@@
    + 				fprintf_ln(stderr, _("Cannot save "
    + 						     "the untracked files"));
    + 			ret = -1;
    +-			*stash_msg = NULL;
    + 			goto done;
    + 		}
    + 		untracked_commit_option = 1;
    + 	}
    + 	if (patch_mode) {
    + 		ret = stash_patch(info, ps, patch, quiet);
    +-		*stash_msg = NULL;
    + 		if (ret < 0) {
    + 			if (!quiet)
    + 				fprintf_ln(stderr, _("Cannot save the current "
    +@@
    + 				fprintf_ln(stderr, _("Cannot save the current "
    + 						     "worktree state"));
    + 			ret = -1;
    +-			*stash_msg = NULL;
    + 			goto done;
    + 		}
    + 	}
    +@@
    + 	else
    + 		strbuf_addf(&stash_msg_buf, "On %s: %s", branch_name,
    + 			    *stash_msg);
    +-	*stash_msg = strbuf_detach(&stash_msg_buf, NULL);
    ++	*stash_msg = xstrdup(stash_msg_buf.buf);
    + 
    + 	/*
    + 	 * `parents` will be empty after calling `commit_tree()`, so there is
    +@@
      
      static int create_stash(int argc, const char **argv, const char *prefix)
      {
    @@ -264,9 +320,9 @@
     -	argc = parse_options(argc, argv, prefix, options,
     -			     git_stash_helper_create_usage,
     -			     0);
    -+	/* Startinf with argv[1], since argv[0] is "create" */
    -+	stash_msg = (char*) strbuf_join_argv(&stash_msg_buf, argc - 1,
    -+					     ++argv, ' ');
    ++	/* Starting with argv[1], since argv[0] is "create" */
    ++	strbuf_join_argv(&stash_msg_buf, argc - 1, ++argv, ' ');
    ++	stash_msg = stash_msg_buf.buf;
      
      	memset(&ps, 0, sizeof(ps));
     -	ret = do_create_stash(ps, &stash_msg, include_untracked, 0, &info,
    @@ -277,15 +333,9 @@
      		printf_ln("%s", oid_to_hex(&info.w_commit));
      
     +	strbuf_release(&stash_msg_buf);
    -+
    - 	/*
    - 	 * ret can be 1 if there were no changes. In this case, we should
    - 	 * not error out.
    - 	 */
    --	free((char *) stash_msg);
    - 	return ret < 0;
    - }
    + 	free(stash_msg);
      
    + 	/*
     @@
      		OPT_END()
      	};
    @@ -299,7 +349,7 @@
     +				     0);
      
      	parse_pathspec(&ps, 0, PATHSPEC_PREFER_FULL, prefix, argv);
    - 	return do_push_stash(ps, stash_msg, quiet, keep_index, patch_mode,
    + 	return do_push_stash(ps, xstrdup_or_null(stash_msg), quiet,
     @@
      	};
      
    @@ -308,7 +358,7 @@
     +			     git_stash_save_usage,
      			     PARSE_OPT_KEEP_DASHDASH);
      
    - 	if (argc)
    + 	if (argc) {
     @@
      	return ret;
      }
    @@ -375,10 +425,8 @@
     +			 * they need to be immediately followed by a string
     +			 * (i.e.`-m"foobar"` or `--message="foobar"`).
     +			 */
    -+			if ((strlen(argv[i]) > 2 &&
    -+			     !strncmp(argv[i], "-m", 2)) ||
    -+			    (strlen(argv[i]) > 10 &&
    -+			     !strncmp(argv[i], "--message=", 10)))
    ++			if (starts_with(argv[i], "-m") ||
    ++			    starts_with(argv[i], "--message="))
     +				continue;
     +
     +			usage_with_options(git_stash_usage, options);
20:  92dc11fd16 ! 20:  a384b05008 stash: optimize `get_untracked_files()` and `check_changes()`
    @@ -52,7 +52,6 @@
     +static int check_changes_tracked_files(struct pathspec ps)
      {
      	int result;
    --	int ret = 0;
      	struct rev_info rev;
      	struct object_id dummy;
     -	struct strbuf out = STRBUF_INIT;
    @@ -99,8 +98,8 @@
     -	if (!check_changes(ps, include_untracked)) {
     +	if (!check_changes(ps, include_untracked, &untracked_files)) {
      		ret = 1;
    - 		*stash_msg = NULL;
      		goto done;
    + 	}
     @@
      		goto done;
      	}
    @@ -110,9 +109,9 @@
     +	if (include_untracked) {
      		if (save_untracked_files(info, &msg, untracked_files)) {
      			if (!quiet)
    - 				fprintf_ln(stderr, _("Cannot save the untracked files"));
    + 				fprintf_ln(stderr, _("Cannot save "
     @@
    - 					     ++argv, ' ');
    + 	stash_msg = stash_msg_buf.buf;
      
      	memset(&ps, 0, sizeof(ps));
     -	ret = do_create_stash(ps, &stash_msg, 0, 0, &info, NULL, 0);
    @@ -124,6 +123,7 @@
      		printf_ln("%s", oid_to_hex(&info.w_commit));
      
      	strbuf_release(&stash_msg_buf);
    + 	free(stash_msg);
     -
     -	/*
     -	 * ret can be 1 if there were no changes. In this case, we should
    @@ -148,6 +148,6 @@
      
     -	if (!check_changes(ps, include_untracked)) {
     +	if (!check_changes(ps, include_untracked, &untracked_files)) {
    - 		stash_msg = NULL;
      		if (!quiet)
      			printf_ln(_("No local changes to save"));
    + 		goto done;

21: 2c40c9232a = 21: 825d1e6ef1 stash: replace all write-tree child processes with API calls

Quoted 51 lines

[1]
https://public-inbox.org/git/[email protected]/

[2]
https://github.com/git-for-windows/git/commit/2af24038a95a3879aa0c29d91a43180b9465247e

Joel Teichroeb (5):
stash: improve option parsing test coverage
stash: convert apply to builtin
stash: convert drop and clear to builtin
stash: convert branch to builtin
stash: convert pop to builtin

Paul-Sebastian Ungureanu (16):
sha1-name.c: add get_oidf() which acts like get_oid() strbuf.c: add strbuf_join_argv()
t3903: modernize style
stash: rename test cases to be more descriptive
stash: add tests for git stash show config
stash: mention options in show synopsis
stash: convert list to builtin
stash: convert show to builtin
stash: convert store to builtin
stash: convert create to builtin
stash: convert push to builtin
stash: make push -q quiet
stash: convert save to builtin
stash: convert stash--helper.c into stash.c
stash: optimize get_untracked_files() and check_changes()
stash: replace all write-tree child processes with API calls

 Documentation/git-stash.txt  |    4 +-
 Makefile                     |    2 +-
 builtin.h                    |    1 +
 builtin/stash.c              | 1605 ++++++++++++++++++++++++++++++++++
 cache.h                      |    1 +
 git-stash.sh                 |  752 ----------------
 git.c                        |    1 +
 sha1-name.c                  |   19 +
 strbuf.c                     |   13 +
 strbuf.h                     |    7 +
 t/t3903-stash.sh             |  192 ++--
 t/t3907-stash-show-config.sh |   83 ++
 12 files changed, 1859 insertions(+), 821 deletions(-)
 create mode 100644 builtin/stash.c
 delete mode 100755 git-stash.sh
 create mode 100755 t/t3907-stash-show-config.sh
Signature · 1 line
2.19.0.rc0.23.g10a62394e7
#28 lore raw

Re: [PATCH v10 00/21] Convert "git stash" to C builtin

Quoted 9 lines · Thomas Gummerer
Quoted 7 lines · Paul-Sebastian Ungureanu

Hello,

This is a new iteration of git stash, based on the last review. This iteration fixes some code styling issues, bring some changes to do_push_stash() and do_create_stash() to be closer to API by following Thomas Gummerer's review of last iteration [1]. Also, there were some missing messages [2], which are now included.

Quoted 3 lines

Thanks for your work! I had two more comments (on the patches inline). Once those are addressed, I'd be happy for this to be merged to 'next'.

Thank you for your tireless reviews. They were quite helpful and reasonable.

#29 lore raw

Re: [PATCH v10 00/21] Convert "git stash" to C builtin

In reply to Thomas Gummerer

Hi Thomas,

Quoted 9 lines · Thomas Gummerer

2: 63f2e0e6f9 ! 2: 2d45985676 strbuf.c: add strbuf_join_argv()
@@ -14,19 +14,17 @@
strbuf_setlen(sb, sb->len + sb2->len);
}

-+const char *strbuf_join_argv(struct strbuf *buf,
-+ int argc, const char **argv, char delim)
++void strbuf_join_argv(struct strbuf *buf,
++ int argc, const char **argv, char delim)

While the patch series does not use the return value, I have to ask whether it would really be useful to change it to return void. I could imagine that there may already be quite a few code paths that would love to use strbuf_join_argv(), *and* would benefit from the const char * return value.

In other words: just because the *current* patches do not make use of that quite convenient return value does not mean that we should remove that convenience.

Quoted 8 lines

7: a2abd1b4bd ! 8: 974dbaa492 stash: convert apply to builtin

    @@ -370,18 +370,20 @@
     +
     +			if (diff_tree_binary(&out, &info->w_commit)) {
     +				strbuf_release(&out);
    -+				return -1;
    ++				return error(_("Could not generate diff %s^!."),
    ++					     oid_to_hex(&info->w_commit));

Please start the argument of an error() call with a lower-case letter.

Quoted 8 lines
     +			}
     +
     +			ret = apply_cached(&out);
     +			strbuf_release(&out);
     +			if (ret)
    -+				return -1;
    ++				return error(_("Conflicts in index."
    ++					       "Try without --index."));

Same here.

Quoted 6 lines
     +
     +			discard_cache();
     +			read_cache();
     +			if (write_cache_as_tree(&index_tree, 0, NULL))
    -+				return -1;
    ++				return error(_("Could not save index tree"));

And here.

Quoted 6 lines

15: bd827be103 ! 15: 989db67e9a stash: convert create to builtin

    @@ -119,7 +119,6 @@
     +static int check_changes(struct pathspec ps, int include_untracked)
     +{
     +	int result;
    -+	int ret = 0;

I was curious about this change, and could not find it in the git-stash-v10 tag of https://github.com/ungps/git...

Quoted 11 lines

18: 1c501ad666 ! 18: c90e30173a stash: convert save to builtin

    @@ -72,8 +72,10 @@
     +			     git_stash_helper_save_usage,
     +			     PARSE_OPT_KEEP_DASHDASH);
     +
    -+	if (argc)
    -+		stash_msg = (char*) strbuf_join_argv(&buf, argc, argv, ' ');
    ++	if (argc) {
    ++		strbuf_join_argv(&buf, argc, argv, ' ');
    ++		stash_msg = buf.buf;
    ++	}

Aha! So there *was* a user of that return value. I really would prefer a non-void return value here.

Quoted 11 lines

19: c4401b21db ! 19: 4360ea875d stash: convert stash--helper.c into stash.c

    @@ -264,9 +320,9 @@
     -	argc = parse_options(argc, argv, prefix, options,
     -			     git_stash_helper_create_usage,
     -			     0);
    -+	/* Startinf with argv[1], since argv[0] is "create" */
    -+	stash_msg = (char*) strbuf_join_argv(&stash_msg_buf, argc - 1,
    -+					     ++argv, ' ');
    ++	/* Starting with argv[1], since argv[0] is "create" */
    ++	strbuf_join_argv(&stash_msg_buf, argc - 1, ++argv, ' ');
    ++	stash_msg = stash_msg_buf.buf;

Again, I would strongly prefer the convenience of assigning the return value directly, rather than having two lines.

Quoted 10 lines
    @@ -375,10 +425,8 @@
     +			 * they need to be immediately followed by a string
     +			 * (i.e.`-m"foobar"` or `--message="foobar"`).
     +			 */
    -+			if ((strlen(argv[i]) > 2 &&
    -+			     !strncmp(argv[i], "-m", 2)) ||
    -+			    (strlen(argv[i]) > 10 &&
    -+			     !strncmp(argv[i], "--message=", 10)))
    ++			if (starts_with(argv[i], "-m") ||
    ++			    starts_with(argv[i], "--message="))

Very nice.

Quoted 6 lines

20: 92dc11fd16 ! 20: a384b05008 stash: optimize get_untracked_files() and check_changes()

    @@ -52,7 +52,6 @@
     +static int check_changes_tracked_files(struct pathspec ps)
      {
      	int result;
    --	int ret = 0;

I also wonder about this change, in light of...

Quoted 7 lines
      	struct rev_info rev;
      	struct object_id dummy;
     -	struct strbuf out = STRBUF_INIT;
    @@ -99,8 +98,8 @@
     -	if (!check_changes(ps, include_untracked)) {
     +	if (!check_changes(ps, include_untracked, &untracked_files)) {
      		ret = 1;

this here line. How does that work, if ret is removed? And why didn't the make DEVELOPER=1 complain about that unused ret variable before?

Quoted 5 lines
    - 		*stash_msg = NULL;
      		goto done;
    + 	}
     @@
      		goto done;

The rest of the changes looks pretty sensible to me (indentation/wrapping changes, mostly, with a couple of commit message/typo fixes thrown in).

Maybe you have a commit hash, or even better, a tag in a public Git repository somewhere, so that Paul can pick it up more easily (and compare the changes with his latest local branch)?

Thank you!
Dscho

#30 lore raw

Re: [PATCH v10 00/21] Convert "git stash" to C builtin

Quoted 14 lines · Johannes Schindelin

Hi Thomas,

Quoted 9 lines · Thomas Gummerer

2: 63f2e0e6f9 ! 2: 2d45985676 strbuf.c: add strbuf_join_argv()
@@ -14,19 +14,17 @@
strbuf_setlen(sb, sb->len + sb2->len);
}

-+const char *strbuf_join_argv(struct strbuf *buf,
-+ int argc, const char **argv, char delim)
++void strbuf_join_argv(struct strbuf *buf,
++ int argc, const char **argv, char delim)

Quoted 5 lines

While the patch series does not use the return value, I have to ask whether it would really be useful to change it to return void. I could imagine that there may already be quite a few code paths that would love to use strbuf_join_argv(), *and* would benefit from the const char * return value.

Fair enough. I did suggest changing the return type to void here, as I found the API a bit odd compared to the rest of the strbuf API, however after looking at this again I agree with you, and returning a const char * here does seem more helpful. Sorry about the confusion Paul-Sebastian!

Quoted 13 lines

In other words: just because the *current* patches do not make use of that quite convenient return value does not mean that we should remove that convenience.

Quoted 8 lines

7: a2abd1b4bd ! 8: 974dbaa492 stash: convert apply to builtin

    @@ -370,18 +370,20 @@
     +
     +			if (diff_tree_binary(&out, &info->w_commit)) {
     +				strbuf_release(&out);
    -+				return -1;
    ++				return error(_("Could not generate diff %s^!."),
    ++					     oid_to_hex(&info->w_commit));
Quoted 1 line

Please start the argument of an error() call with a lower-case letter.

I think this comes from your fixup! commit ;) But I do agree, these should be lower-case.

Quoted 27 lines
Quoted 8 lines
     +			}
     +
     +			ret = apply_cached(&out);
     +			strbuf_release(&out);
     +			if (ret)
    -+				return -1;
    ++				return error(_("Conflicts in index."
    ++					       "Try without --index."));

Same here.

Quoted 6 lines
     +
     +			discard_cache();
     +			read_cache();
     +			if (write_cache_as_tree(&index_tree, 0, NULL))
    -+				return -1;
    ++				return error(_("Could not save index tree"));

And here.

Quoted 6 lines

15: bd827be103 ! 15: 989db67e9a stash: convert create to builtin

    @@ -119,7 +119,6 @@
     +static int check_changes(struct pathspec ps, int include_untracked)
     +{
     +	int result;
    -+	int ret = 0;
Quoted 2 lines

I was curious about this change, and could not find it in the git-stash-v10 tag of https://github.com/ungps/git...

This line has been removed in v10, but did exist in v9, so the git-stash-v10 should indeed not have this line. I suggested removing it in [*1*], because it breaks compilation with DEVELOPER=1 at this step.

Quoted 12 lines
Quoted 11 lines

18: 1c501ad666 ! 18: c90e30173a stash: convert save to builtin

    @@ -72,8 +72,10 @@
     +			     git_stash_helper_save_usage,
     +			     PARSE_OPT_KEEP_DASHDASH);
     +
    -+	if (argc)
    -+		stash_msg = (char*) strbuf_join_argv(&buf, argc, argv, ' ');
    ++	if (argc) {
    ++		strbuf_join_argv(&buf, argc, argv, ' ');
    ++		stash_msg = buf.buf;
    ++	}
Quoted 2 lines

Aha! So there *was* a user of that return value. I really would prefer a non-void return value here.

Right, I'd argue we're mis-using the API here though. do_push_stash who we later pass stash_msg to takes ownership and later free's the memory before returning. This doesn't cause issues in the test suite at the moment, because do_create_stash() doesn't always free stash_msg before assigning a new value to the pointer, but would cause issues when do_create_stash exits early.

Rather than the solution I proposed in I think it would be nicer to use 'stash_msg = strbuf_detach(...)' above.

I'm still happy with the function returning buf->buf as const char *, but I'm not sure we should use that return value here.

Quoted 12 lines
Quoted 11 lines

19: c4401b21db ! 19: 4360ea875d stash: convert stash--helper.c into stash.c

    @@ -264,9 +320,9 @@
     -	argc = parse_options(argc, argv, prefix, options,
     -			     git_stash_helper_create_usage,
     -			     0);
    -+	/* Startinf with argv[1], since argv[0] is "create" */
    -+	stash_msg = (char*) strbuf_join_argv(&stash_msg_buf, argc - 1,
    -+					     ++argv, ' ');
    ++	/* Starting with argv[1], since argv[0] is "create" */
    ++	strbuf_join_argv(&stash_msg_buf, argc - 1, ++argv, ' ');
    ++	stash_msg = stash_msg_buf.buf;
Quoted 2 lines

Again, I would strongly prefer the convenience of assigning the return value directly, rather than having two lines.

This is a similar case as above, where I think using strbuf_detach would be best, again instead of the 'xstrdup()' I mentioned in [*2*].

Quoted 13 lines
Quoted 10 lines
    @@ -375,10 +425,8 @@
     +			 * they need to be immediately followed by a string
     +			 * (i.e.`-m"foobar"` or `--message="foobar"`).
     +			 */
    -+			if ((strlen(argv[i]) > 2 &&
    -+			     !strncmp(argv[i], "-m", 2)) ||
    -+			    (strlen(argv[i]) > 10 &&
    -+			     !strncmp(argv[i], "--message=", 10)))
    ++			if (starts_with(argv[i], "-m") ||
    ++			    starts_with(argv[i], "--message="))

Very nice.

Quoted 8 lines
Quoted 6 lines

20: 92dc11fd16 ! 20: a384b05008 stash: optimize get_untracked_files() and check_changes()

    @@ -52,7 +52,6 @@
     +static int check_changes_tracked_files(struct pathspec ps)
      {
      	int result;
    --	int ret = 0;

I also wonder about this change, in light of...

The double - in the beginning of the range diff indicates that the removal of this line was removed from this particular patch (the removal is now done in patch 15 instead). I think this is one of those cases where the range-diff is a bit hard to interpret, especially without the --dual-color mode :)

Quoted 10 lines
Quoted 7 lines
      	struct rev_info rev;
      	struct object_id dummy;
     -	struct strbuf out = STRBUF_INIT;
    @@ -99,8 +98,8 @@
     -	if (!check_changes(ps, include_untracked)) {
     +	if (!check_changes(ps, include_untracked, &untracked_files)) {
      		ret = 1;

this here line. How does that work, if ret is removed? And why didn't the make DEVELOPER=1 complain about that unused ret variable before?

This is a different function, the above is in the 'check_changes_tracked_files()' function, while we are in the 'do_create_stash()' function, which has a local 'ret' variable.

Quoted 7 lines
Quoted 6 lines
    - 		*stash_msg = NULL;
      		goto done;
    + 	}
     @@
      		goto done;
Quoted 6 lines

The rest of the changes looks pretty sensible to me (indentation/wrapping changes, mostly, with a couple of commit message/typo fixes thrown in).

Maybe you have a commit hash, or even better, a tag in a public Git repository somewhere, so that Paul can pick it up more easily (and compare the changes with his latest local branch)?

The range-diff here between Paul's v9 and v10 series. I just applied both series, and sent out the range-diff in case someone else prefered not applying both series, or fetching both from Paul's repo, but reading the range-diff (and I got you to comment on it, which I already found helpful :)). There are no changes of my own included in this.

Quoted 2 lines

Thank you!
Dscho

[*1*]: https://public-inbox.org/git/[email protected]/
[*2*]: https://public-inbox.org/git/[email protected]/