Re: "git reset" and newly created files.

Sam Ravnborg [off-list ref] writes:

quoted

So you would naturally be tempted to do this:

    ... Re-edit, compile, and test.  This time it is perfect.
    $ git commit -a -C ORIG_HEAD

Well, not really.  You can lose any file newly created in
ORIG_HEAD this way.  Instead, you need to do this:

    ... Re-edit, compile, and test.  This time it is perfect.
    $ git add <whatever file you have changed>
    $ git commit -a -C ORIG_HEAD

Do people find this a big problem?

I often do some maybe not that brilliant changes in my tree,
and when I then ask git to reset these I expect git to reset
everything.

After a git-reset HEAD^ I really expect git to have rewinded back till
where I started with no files added whatsoever.

That is another thing I initially expected from the "git reset"
command, but I do not think that is what this command is about.
It is about reverting your working tree and index file to the
state just before you make your commit to create the botched
commit, so that you can make minor fixes and recommit.

Viewing it that way, it might even be a good idea to "git add"
the files that are in ORIG_HEAD but not in the head you are
"resetting" to.

From the matter of least suprise git should not remember files added,
one have to do that by themself again if needed.

What I was getting at was that doing things that way means new
files and modified files are handled inconsistently.  With the
current implementation, git "remembers" the files modified, but
not files added.  And if the purpose of "reset" is to eventually
re-commit, it would be useful if git remembers both, not just
modified files.

One way to achieve that would be "git-update-cache --add-maybe"
I talked about in the original message, but at least something
like the following would still be an improvement.  Instead of
echoing the output from diff-tree, we might even be better off
if we just feed it to "xargs git-update-cache --add".

------------
[PATCH] Remind the user of "about to be lost" files. 

Files that are in the current HEAD but not in the head we are
resetting to can easily be lost when "git reset HEAD^" is
followed by re-edit and "git commit".

This patch reminds the user about those files.

Signed-off-by: Junio C Hamano <redacted>

---

diff --git a/git-reset-script b/git-reset-script
--- a/git-reset-script
+++ b/git-reset-script

@@ -6,6 +6,16 @@ git-read-tree --reset "$rev" && {
 	if orig=$(git-rev-parse --verify HEAD 2>/dev/null)
 	then
 		echo "$orig" >"$GIT_DIR/ORIG_HEAD"
+
+		# Remind the user about files that are in ORIG_HEAD
+		# but not in $rev.  We would really want to do
+		# "git-update-cache --add-maybe" on these paths, but
+		# that is not available (yet).
+		git-diff-tree -r --diff-filter=D $rev ORIG_HEAD |
+		while path
+		do
+			echo "$path: needs add"
+		done
 	fi
 	echo "$rev" > "$GIT_DIR/HEAD"
 }