2007-09-11 05:19:34 +02:00
|
|
|
/*
|
|
|
|
|
* "git reset" builtin command
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2007 Carlos Rica
|
|
|
|
|
*
|
|
|
|
|
* Based on git-reset.sh, which is
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2005, 2006 Linus Torvalds and Junio C Hamano
|
|
|
|
|
*/
|
Fix sparse warnings
Fix warnings from 'make check'.
- These files don't include 'builtin.h' causing sparse to complain that
cmd_* isn't declared:
builtin/clone.c:364, builtin/fetch-pack.c:797,
builtin/fmt-merge-msg.c:34, builtin/hash-object.c:78,
builtin/merge-index.c:69, builtin/merge-recursive.c:22
builtin/merge-tree.c:341, builtin/mktag.c:156, builtin/notes.c:426
builtin/notes.c:822, builtin/pack-redundant.c:596,
builtin/pack-refs.c:10, builtin/patch-id.c:60, builtin/patch-id.c:149,
builtin/remote.c:1512, builtin/remote-ext.c:240,
builtin/remote-fd.c:53, builtin/reset.c:236, builtin/send-pack.c:384,
builtin/unpack-file.c:25, builtin/var.c:75
- These files have symbols which should be marked static since they're
only file scope:
submodule.c:12, diff.c:631, replace_object.c:92, submodule.c:13,
submodule.c:14, trace.c:78, transport.c:195, transport-helper.c:79,
unpack-trees.c:19, url.c:3, url.c:18, url.c:104, url.c:117, url.c:123,
url.c:129, url.c:136, thread-utils.c:21, thread-utils.c:48
- These files redeclare symbols to be different types:
builtin/index-pack.c:210, parse-options.c:564, parse-options.c:571,
usage.c:49, usage.c:58, usage.c:63, usage.c:72
- These files use a literal integer 0 when they really should use a NULL
pointer:
daemon.c:663, fast-import.c:2942, imap-send.c:1072, notes-merge.c:362
While we're in the area, clean up some unused #includes in builtin files
(mostly exec_cmd.h).
Signed-off-by: Stephen Boyd <bebarino@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-22 08:51:05 +01:00
|
|
|
#include "builtin.h"
|
2007-09-11 05:19:34 +02:00
|
|
|
#include "tag.h"
|
|
|
|
|
#include "object.h"
|
|
|
|
|
#include "commit.h"
|
|
|
|
|
#include "run-command.h"
|
|
|
|
|
#include "refs.h"
|
|
|
|
|
#include "diff.h"
|
|
|
|
|
#include "diffcore.h"
|
|
|
|
|
#include "tree.h"
|
2008-02-07 17:40:16 +01:00
|
|
|
#include "branch.h"
|
2008-03-04 23:11:34 +01:00
|
|
|
#include "parse-options.h"
|
2009-12-30 06:54:47 +01:00
|
|
|
#include "unpack-trees.h"
|
|
|
|
|
#include "cache-tree.h"
|
2007-09-11 05:19:34 +02:00
|
|
|
|
2008-03-04 23:11:34 +01:00
|
|
|
static const char * const git_reset_usage[] = {
|
2012-08-20 14:32:39 +02:00
|
|
|
N_("git reset [--mixed | --soft | --hard | --merge | --keep] [-q] [<commit>]"),
|
2013-01-16 19:00:35 +01:00
|
|
|
N_("git reset [-q] <tree-ish> [--] <paths>..."),
|
|
|
|
|
N_("git reset --patch [<tree-ish>] [--] [<paths>...]"),
|
2008-03-04 23:11:34 +01:00
|
|
|
NULL
|
|
|
|
|
};
|
2007-09-11 05:19:34 +02:00
|
|
|
|
2010-01-19 05:25:57 +01:00
|
|
|
enum reset_type { MIXED, SOFT, HARD, MERGE, KEEP, NONE };
|
|
|
|
|
static const char *reset_type_names[] = {
|
2011-02-23 00:42:07 +01:00
|
|
|
N_("mixed"), N_("soft"), N_("hard"), N_("merge"), N_("keep"), NULL
|
2010-01-19 05:25:57 +01:00
|
|
|
};
|
Add 'merge' mode to 'git reset'
We have always had a nice way to reset a working tree to another state
while carrying our changes around: "git read-tree -u -m". Yes, it fails if
the target tree is different in the paths that are dirty in the working
tree, but this is how we used to switch branches in "git checkout", and it
worked fine.
However, perhaps exactly _because_ we've supported this from very early
on, another low-level command, namely "git reset", never did.
But as time went on, 'git reset' remains as a very common command, while
'git read-tree' is now a very odd and low-level plumbing thing that nobody
sane should ever use, because it only makes sense together with other
operations like either switching branches or just rewriting HEAD.
Which means that we have effectively lost the ability to do something very
common: jump to another point in time without always dropping all our
dirty state.
So add this kind of mode to "git reset", and since it merges your changes
to what you are resetting to, just call it that: "git reset --merge".
I've wanted this for a long time, since I very commonly carry a dirty
tree while working on things. My main 'Makefile' file quite often has the
next version already modified, and sometimes I have local modifications
that I don't want to commit, but I still do pulls and patch applications,
and occasionally want to do "git reset" to undo them - while still keeping
my local modifications.
(Maybe we could eventually change it to something like "if we have a
working tree, default to --merge, otherwise default to --mixed").
NOTE! This new mode is certainly not perfect. There's a few things to look
out for:
- if the index has unmerged entries, "--merge" will currently simply
refuse to reset ("you need to resolve your current index first").
You'll need to use "--hard" or similar in this case.
This is sad, because normally a unmerged index means that the working
tree file should have matched the source tree, so the correct action is
likely to make --merge reset such a path to the target (like --hard),
regardless of dirty state in-tree or in-index. But that's not how
read-tree has ever worked, so..
- "git checkout -m" actually knows how to do a three-way merge, rather
than refuse to update the working tree. So we do know how to do that,
and arguably that would be even nicer behavior.
At the same time it's also arguably true that there is a chance of loss
of state (ie you cannot get back to the original tree if the three-way
merge ends up resolving cleanly to no diff at all), so the "refuse to
do it" is in some respects the safer - but less user-friendly - option.
In other words, I think 'git reset --merge' could become a bit more
friendly, but this is already a big improvement. It allows you to undo a
recent commit without having to throw your current work away.
Yes, yes, with a dirty tree you could always do
git stash
git reset --hard
git stash apply
instead, but isn't "git reset --merge" a nice way to handle one particular
simple case?
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
--
Hmm? Maybe I'm the only one that does a lot of work with a dirty tree, and
sure, I can do other things like the "git stash" thing, or using "git
checkout" to actually create a new branch, and then playing games with
branch renaming etc to make it work like this one.
But I suspect others dislike how "git reset" works too. But see the
suggested improvements above.
builtin-reset.c | 26 ++++++++++++++++++--------
1 files changed, 18 insertions(+), 8 deletions(-)
2008-12-01 18:30:31 +01:00
|
|
|
|
2007-09-11 05:19:34 +02:00
|
|
|
static inline int is_merge(void)
|
|
|
|
|
{
|
|
|
|
|
return !access(git_path("MERGE_HEAD"), F_OK);
|
|
|
|
|
}
|
|
|
|
|
|
reset --keep: only write index file once
"git reset --keep" calls reset_index_file() twice, first doing a
two-way merge to the target revision, updating the index and worktree,
and then resetting the index. After each call, we write the index
file.
In the unlikely event that the second call to reset_index_file()
fails, the index will have been merged to the target revision, but
HEAD will not be updated, leaving the user with a dirty index.
By moving the locking, writing and committing out of
reset_index_file() and into the caller, we can avoid writing the index
twice, thereby making the sure we don't end up in the half-way reset
state. As a bonus, we speed up "git reset --keep" a little on the
linux-2.6 repo (best of five, warm cache):
Before After
real 0m0.315s 0m0.296s
user 0m0.290s 0m0.280s
sys 0m0.020s 0m0.010s
Signed-off-by: Martin von Zweigbergk <martinvonz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-15 06:47:41 +01:00
|
|
|
static int reset_index(const unsigned char *sha1, int reset_type, int quiet)
|
2007-09-11 05:19:34 +02:00
|
|
|
{
|
2009-12-30 06:54:47 +01:00
|
|
|
int nr = 1;
|
|
|
|
|
struct tree_desc desc[2];
|
2011-12-06 18:43:39 +01:00
|
|
|
struct tree *tree;
|
2009-12-30 06:54:47 +01:00
|
|
|
struct unpack_trees_options opts;
|
2007-09-11 05:19:34 +02:00
|
|
|
|
2009-12-30 06:54:47 +01:00
|
|
|
memset(&opts, 0, sizeof(opts));
|
|
|
|
|
opts.head_idx = 1;
|
|
|
|
|
opts.src_index = &the_index;
|
|
|
|
|
opts.dst_index = &the_index;
|
|
|
|
|
opts.fn = oneway_merge;
|
|
|
|
|
opts.merge = 1;
|
2008-06-01 03:10:58 +02:00
|
|
|
if (!quiet)
|
2009-12-30 06:54:47 +01:00
|
|
|
opts.verbose_update = 1;
|
Add 'merge' mode to 'git reset'
We have always had a nice way to reset a working tree to another state
while carrying our changes around: "git read-tree -u -m". Yes, it fails if
the target tree is different in the paths that are dirty in the working
tree, but this is how we used to switch branches in "git checkout", and it
worked fine.
However, perhaps exactly _because_ we've supported this from very early
on, another low-level command, namely "git reset", never did.
But as time went on, 'git reset' remains as a very common command, while
'git read-tree' is now a very odd and low-level plumbing thing that nobody
sane should ever use, because it only makes sense together with other
operations like either switching branches or just rewriting HEAD.
Which means that we have effectively lost the ability to do something very
common: jump to another point in time without always dropping all our
dirty state.
So add this kind of mode to "git reset", and since it merges your changes
to what you are resetting to, just call it that: "git reset --merge".
I've wanted this for a long time, since I very commonly carry a dirty
tree while working on things. My main 'Makefile' file quite often has the
next version already modified, and sometimes I have local modifications
that I don't want to commit, but I still do pulls and patch applications,
and occasionally want to do "git reset" to undo them - while still keeping
my local modifications.
(Maybe we could eventually change it to something like "if we have a
working tree, default to --merge, otherwise default to --mixed").
NOTE! This new mode is certainly not perfect. There's a few things to look
out for:
- if the index has unmerged entries, "--merge" will currently simply
refuse to reset ("you need to resolve your current index first").
You'll need to use "--hard" or similar in this case.
This is sad, because normally a unmerged index means that the working
tree file should have matched the source tree, so the correct action is
likely to make --merge reset such a path to the target (like --hard),
regardless of dirty state in-tree or in-index. But that's not how
read-tree has ever worked, so..
- "git checkout -m" actually knows how to do a three-way merge, rather
than refuse to update the working tree. So we do know how to do that,
and arguably that would be even nicer behavior.
At the same time it's also arguably true that there is a chance of loss
of state (ie you cannot get back to the original tree if the three-way
merge ends up resolving cleanly to no diff at all), so the "refuse to
do it" is in some respects the safer - but less user-friendly - option.
In other words, I think 'git reset --merge' could become a bit more
friendly, but this is already a big improvement. It allows you to undo a
recent commit without having to throw your current work away.
Yes, yes, with a dirty tree you could always do
git stash
git reset --hard
git stash apply
instead, but isn't "git reset --merge" a nice way to handle one particular
simple case?
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
--
Hmm? Maybe I'm the only one that does a lot of work with a dirty tree, and
sure, I can do other things like the "git stash" thing, or using "git
checkout" to actually create a new branch, and then playing games with
branch renaming etc to make it work like this one.
But I suspect others dislike how "git reset" works too. But see the
suggested improvements above.
builtin-reset.c | 26 ++++++++++++++++++--------
1 files changed, 18 insertions(+), 8 deletions(-)
2008-12-01 18:30:31 +01:00
|
|
|
switch (reset_type) {
|
2010-01-19 05:25:57 +01:00
|
|
|
case KEEP:
|
Add 'merge' mode to 'git reset'
We have always had a nice way to reset a working tree to another state
while carrying our changes around: "git read-tree -u -m". Yes, it fails if
the target tree is different in the paths that are dirty in the working
tree, but this is how we used to switch branches in "git checkout", and it
worked fine.
However, perhaps exactly _because_ we've supported this from very early
on, another low-level command, namely "git reset", never did.
But as time went on, 'git reset' remains as a very common command, while
'git read-tree' is now a very odd and low-level plumbing thing that nobody
sane should ever use, because it only makes sense together with other
operations like either switching branches or just rewriting HEAD.
Which means that we have effectively lost the ability to do something very
common: jump to another point in time without always dropping all our
dirty state.
So add this kind of mode to "git reset", and since it merges your changes
to what you are resetting to, just call it that: "git reset --merge".
I've wanted this for a long time, since I very commonly carry a dirty
tree while working on things. My main 'Makefile' file quite often has the
next version already modified, and sometimes I have local modifications
that I don't want to commit, but I still do pulls and patch applications,
and occasionally want to do "git reset" to undo them - while still keeping
my local modifications.
(Maybe we could eventually change it to something like "if we have a
working tree, default to --merge, otherwise default to --mixed").
NOTE! This new mode is certainly not perfect. There's a few things to look
out for:
- if the index has unmerged entries, "--merge" will currently simply
refuse to reset ("you need to resolve your current index first").
You'll need to use "--hard" or similar in this case.
This is sad, because normally a unmerged index means that the working
tree file should have matched the source tree, so the correct action is
likely to make --merge reset such a path to the target (like --hard),
regardless of dirty state in-tree or in-index. But that's not how
read-tree has ever worked, so..
- "git checkout -m" actually knows how to do a three-way merge, rather
than refuse to update the working tree. So we do know how to do that,
and arguably that would be even nicer behavior.
At the same time it's also arguably true that there is a chance of loss
of state (ie you cannot get back to the original tree if the three-way
merge ends up resolving cleanly to no diff at all), so the "refuse to
do it" is in some respects the safer - but less user-friendly - option.
In other words, I think 'git reset --merge' could become a bit more
friendly, but this is already a big improvement. It allows you to undo a
recent commit without having to throw your current work away.
Yes, yes, with a dirty tree you could always do
git stash
git reset --hard
git stash apply
instead, but isn't "git reset --merge" a nice way to handle one particular
simple case?
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
--
Hmm? Maybe I'm the only one that does a lot of work with a dirty tree, and
sure, I can do other things like the "git stash" thing, or using "git
checkout" to actually create a new branch, and then playing games with
branch renaming etc to make it work like this one.
But I suspect others dislike how "git reset" works too. But see the
suggested improvements above.
builtin-reset.c | 26 ++++++++++++++++++--------
1 files changed, 18 insertions(+), 8 deletions(-)
2008-12-01 18:30:31 +01:00
|
|
|
case MERGE:
|
2009-12-30 06:54:47 +01:00
|
|
|
opts.update = 1;
|
Add 'merge' mode to 'git reset'
We have always had a nice way to reset a working tree to another state
while carrying our changes around: "git read-tree -u -m". Yes, it fails if
the target tree is different in the paths that are dirty in the working
tree, but this is how we used to switch branches in "git checkout", and it
worked fine.
However, perhaps exactly _because_ we've supported this from very early
on, another low-level command, namely "git reset", never did.
But as time went on, 'git reset' remains as a very common command, while
'git read-tree' is now a very odd and low-level plumbing thing that nobody
sane should ever use, because it only makes sense together with other
operations like either switching branches or just rewriting HEAD.
Which means that we have effectively lost the ability to do something very
common: jump to another point in time without always dropping all our
dirty state.
So add this kind of mode to "git reset", and since it merges your changes
to what you are resetting to, just call it that: "git reset --merge".
I've wanted this for a long time, since I very commonly carry a dirty
tree while working on things. My main 'Makefile' file quite often has the
next version already modified, and sometimes I have local modifications
that I don't want to commit, but I still do pulls and patch applications,
and occasionally want to do "git reset" to undo them - while still keeping
my local modifications.
(Maybe we could eventually change it to something like "if we have a
working tree, default to --merge, otherwise default to --mixed").
NOTE! This new mode is certainly not perfect. There's a few things to look
out for:
- if the index has unmerged entries, "--merge" will currently simply
refuse to reset ("you need to resolve your current index first").
You'll need to use "--hard" or similar in this case.
This is sad, because normally a unmerged index means that the working
tree file should have matched the source tree, so the correct action is
likely to make --merge reset such a path to the target (like --hard),
regardless of dirty state in-tree or in-index. But that's not how
read-tree has ever worked, so..
- "git checkout -m" actually knows how to do a three-way merge, rather
than refuse to update the working tree. So we do know how to do that,
and arguably that would be even nicer behavior.
At the same time it's also arguably true that there is a chance of loss
of state (ie you cannot get back to the original tree if the three-way
merge ends up resolving cleanly to no diff at all), so the "refuse to
do it" is in some respects the safer - but less user-friendly - option.
In other words, I think 'git reset --merge' could become a bit more
friendly, but this is already a big improvement. It allows you to undo a
recent commit without having to throw your current work away.
Yes, yes, with a dirty tree you could always do
git stash
git reset --hard
git stash apply
instead, but isn't "git reset --merge" a nice way to handle one particular
simple case?
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
--
Hmm? Maybe I'm the only one that does a lot of work with a dirty tree, and
sure, I can do other things like the "git stash" thing, or using "git
checkout" to actually create a new branch, and then playing games with
branch renaming etc to make it work like this one.
But I suspect others dislike how "git reset" works too. But see the
suggested improvements above.
builtin-reset.c | 26 ++++++++++++++++++--------
1 files changed, 18 insertions(+), 8 deletions(-)
2008-12-01 18:30:31 +01:00
|
|
|
break;
|
|
|
|
|
case HARD:
|
2009-12-30 06:54:47 +01:00
|
|
|
opts.update = 1;
|
Add 'merge' mode to 'git reset'
We have always had a nice way to reset a working tree to another state
while carrying our changes around: "git read-tree -u -m". Yes, it fails if
the target tree is different in the paths that are dirty in the working
tree, but this is how we used to switch branches in "git checkout", and it
worked fine.
However, perhaps exactly _because_ we've supported this from very early
on, another low-level command, namely "git reset", never did.
But as time went on, 'git reset' remains as a very common command, while
'git read-tree' is now a very odd and low-level plumbing thing that nobody
sane should ever use, because it only makes sense together with other
operations like either switching branches or just rewriting HEAD.
Which means that we have effectively lost the ability to do something very
common: jump to another point in time without always dropping all our
dirty state.
So add this kind of mode to "git reset", and since it merges your changes
to what you are resetting to, just call it that: "git reset --merge".
I've wanted this for a long time, since I very commonly carry a dirty
tree while working on things. My main 'Makefile' file quite often has the
next version already modified, and sometimes I have local modifications
that I don't want to commit, but I still do pulls and patch applications,
and occasionally want to do "git reset" to undo them - while still keeping
my local modifications.
(Maybe we could eventually change it to something like "if we have a
working tree, default to --merge, otherwise default to --mixed").
NOTE! This new mode is certainly not perfect. There's a few things to look
out for:
- if the index has unmerged entries, "--merge" will currently simply
refuse to reset ("you need to resolve your current index first").
You'll need to use "--hard" or similar in this case.
This is sad, because normally a unmerged index means that the working
tree file should have matched the source tree, so the correct action is
likely to make --merge reset such a path to the target (like --hard),
regardless of dirty state in-tree or in-index. But that's not how
read-tree has ever worked, so..
- "git checkout -m" actually knows how to do a three-way merge, rather
than refuse to update the working tree. So we do know how to do that,
and arguably that would be even nicer behavior.
At the same time it's also arguably true that there is a chance of loss
of state (ie you cannot get back to the original tree if the three-way
merge ends up resolving cleanly to no diff at all), so the "refuse to
do it" is in some respects the safer - but less user-friendly - option.
In other words, I think 'git reset --merge' could become a bit more
friendly, but this is already a big improvement. It allows you to undo a
recent commit without having to throw your current work away.
Yes, yes, with a dirty tree you could always do
git stash
git reset --hard
git stash apply
instead, but isn't "git reset --merge" a nice way to handle one particular
simple case?
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
--
Hmm? Maybe I'm the only one that does a lot of work with a dirty tree, and
sure, I can do other things like the "git stash" thing, or using "git
checkout" to actually create a new branch, and then playing games with
branch renaming etc to make it work like this one.
But I suspect others dislike how "git reset" works too. But see the
suggested improvements above.
builtin-reset.c | 26 ++++++++++++++++++--------
1 files changed, 18 insertions(+), 8 deletions(-)
2008-12-01 18:30:31 +01:00
|
|
|
/* fallthrough */
|
|
|
|
|
default:
|
2009-12-30 06:54:47 +01:00
|
|
|
opts.reset = 1;
|
Add 'merge' mode to 'git reset'
We have always had a nice way to reset a working tree to another state
while carrying our changes around: "git read-tree -u -m". Yes, it fails if
the target tree is different in the paths that are dirty in the working
tree, but this is how we used to switch branches in "git checkout", and it
worked fine.
However, perhaps exactly _because_ we've supported this from very early
on, another low-level command, namely "git reset", never did.
But as time went on, 'git reset' remains as a very common command, while
'git read-tree' is now a very odd and low-level plumbing thing that nobody
sane should ever use, because it only makes sense together with other
operations like either switching branches or just rewriting HEAD.
Which means that we have effectively lost the ability to do something very
common: jump to another point in time without always dropping all our
dirty state.
So add this kind of mode to "git reset", and since it merges your changes
to what you are resetting to, just call it that: "git reset --merge".
I've wanted this for a long time, since I very commonly carry a dirty
tree while working on things. My main 'Makefile' file quite often has the
next version already modified, and sometimes I have local modifications
that I don't want to commit, but I still do pulls and patch applications,
and occasionally want to do "git reset" to undo them - while still keeping
my local modifications.
(Maybe we could eventually change it to something like "if we have a
working tree, default to --merge, otherwise default to --mixed").
NOTE! This new mode is certainly not perfect. There's a few things to look
out for:
- if the index has unmerged entries, "--merge" will currently simply
refuse to reset ("you need to resolve your current index first").
You'll need to use "--hard" or similar in this case.
This is sad, because normally a unmerged index means that the working
tree file should have matched the source tree, so the correct action is
likely to make --merge reset such a path to the target (like --hard),
regardless of dirty state in-tree or in-index. But that's not how
read-tree has ever worked, so..
- "git checkout -m" actually knows how to do a three-way merge, rather
than refuse to update the working tree. So we do know how to do that,
and arguably that would be even nicer behavior.
At the same time it's also arguably true that there is a chance of loss
of state (ie you cannot get back to the original tree if the three-way
merge ends up resolving cleanly to no diff at all), so the "refuse to
do it" is in some respects the safer - but less user-friendly - option.
In other words, I think 'git reset --merge' could become a bit more
friendly, but this is already a big improvement. It allows you to undo a
recent commit without having to throw your current work away.
Yes, yes, with a dirty tree you could always do
git stash
git reset --hard
git stash apply
instead, but isn't "git reset --merge" a nice way to handle one particular
simple case?
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
--
Hmm? Maybe I'm the only one that does a lot of work with a dirty tree, and
sure, I can do other things like the "git stash" thing, or using "git
checkout" to actually create a new branch, and then playing games with
branch renaming etc to make it work like this one.
But I suspect others dislike how "git reset" works too. But see the
suggested improvements above.
builtin-reset.c | 26 ++++++++++++++++++--------
1 files changed, 18 insertions(+), 8 deletions(-)
2008-12-01 18:30:31 +01:00
|
|
|
}
|
2007-09-11 05:19:34 +02:00
|
|
|
|
2009-12-30 06:54:47 +01:00
|
|
|
read_cache_unmerged();
|
|
|
|
|
|
2010-01-19 05:25:57 +01:00
|
|
|
if (reset_type == KEEP) {
|
|
|
|
|
unsigned char head_sha1[20];
|
|
|
|
|
if (get_sha1("HEAD", head_sha1))
|
2011-02-23 00:42:06 +01:00
|
|
|
return error(_("You do not have a valid HEAD."));
|
2010-01-19 05:25:57 +01:00
|
|
|
if (!fill_tree_descriptor(desc, head_sha1))
|
2011-02-23 00:42:06 +01:00
|
|
|
return error(_("Failed to find tree of HEAD."));
|
2010-01-19 05:25:57 +01:00
|
|
|
nr++;
|
|
|
|
|
opts.fn = twoway_merge;
|
|
|
|
|
}
|
|
|
|
|
|
2009-12-30 06:54:47 +01:00
|
|
|
if (!fill_tree_descriptor(desc + nr - 1, sha1))
|
2011-02-23 00:42:06 +01:00
|
|
|
return error(_("Failed to find tree of %s."), sha1_to_hex(sha1));
|
2009-12-30 06:54:47 +01:00
|
|
|
if (unpack_trees(nr, desc, &opts))
|
|
|
|
|
return -1;
|
2011-12-06 18:43:39 +01:00
|
|
|
|
|
|
|
|
if (reset_type == MIXED || reset_type == HARD) {
|
|
|
|
|
tree = parse_tree_indirect(sha1);
|
|
|
|
|
prime_cache_tree(&active_cache_tree, tree);
|
|
|
|
|
}
|
|
|
|
|
|
2009-12-30 06:54:47 +01:00
|
|
|
return 0;
|
2007-09-11 05:19:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void print_new_head_line(struct commit *commit)
|
|
|
|
|
{
|
2008-03-02 08:43:32 +01:00
|
|
|
const char *hex, *body;
|
2013-06-26 12:19:50 +02:00
|
|
|
char *msg;
|
2007-09-11 05:19:34 +02:00
|
|
|
|
|
|
|
|
hex = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV);
|
2011-02-23 00:42:06 +01:00
|
|
|
printf(_("HEAD is now at %s"), hex);
|
2013-06-26 12:19:50 +02:00
|
|
|
msg = logmsg_reencode(commit, NULL, get_log_output_encoding());
|
|
|
|
|
body = strstr(msg, "\n\n");
|
2007-09-11 05:19:34 +02:00
|
|
|
if (body) {
|
|
|
|
|
const char *eol;
|
|
|
|
|
size_t len;
|
|
|
|
|
body += 2;
|
|
|
|
|
eol = strchr(body, '\n');
|
|
|
|
|
len = eol ? eol - body : strlen(body);
|
|
|
|
|
printf(" %.*s\n", (int) len, body);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
printf("\n");
|
2013-06-26 12:19:50 +02:00
|
|
|
logmsg_free(msg, commit);
|
2007-09-11 05:19:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void update_index_from_diff(struct diff_queue_struct *q,
|
|
|
|
|
struct diff_options *opt, void *data)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
|
struct diff_filespec *one = q->queue[i]->one;
|
2011-07-14 06:36:29 +02:00
|
|
|
if (one->mode && !is_null_sha1(one->sha1)) {
|
2007-09-11 05:19:34 +02:00
|
|
|
struct cache_entry *ce;
|
|
|
|
|
ce = make_cache_entry(one->mode, one->sha1, one->path,
|
|
|
|
|
0, 0);
|
2008-10-05 04:14:40 +02:00
|
|
|
if (!ce)
|
2011-02-23 00:42:06 +01:00
|
|
|
die(_("make_cache_entry failed for path '%s'"),
|
2008-10-05 04:14:40 +02:00
|
|
|
one->path);
|
2007-09-11 05:19:34 +02:00
|
|
|
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD |
|
|
|
|
|
ADD_CACHE_OK_TO_REPLACE);
|
|
|
|
|
} else
|
|
|
|
|
remove_file_from_cache(one->path);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-14 10:35:58 +02:00
|
|
|
static int read_from_tree(const struct pathspec *pathspec,
|
|
|
|
|
unsigned char *tree_sha1)
|
2007-09-11 05:19:34 +02:00
|
|
|
{
|
|
|
|
|
struct diff_options opt;
|
|
|
|
|
|
|
|
|
|
memset(&opt, 0, sizeof(opt));
|
2013-07-14 10:35:58 +02:00
|
|
|
copy_pathspec(&opt.pathspec, pathspec);
|
2007-09-11 05:19:34 +02:00
|
|
|
opt.output_format = DIFF_FORMAT_CALLBACK;
|
|
|
|
|
opt.format_callback = update_index_from_diff;
|
|
|
|
|
|
|
|
|
|
read_cache();
|
|
|
|
|
if (do_diff_cache(tree_sha1, &opt))
|
|
|
|
|
return 1;
|
|
|
|
|
diffcore_std(&opt);
|
|
|
|
|
diff_flush(&opt);
|
2013-07-14 10:35:58 +02:00
|
|
|
free_pathspec(&opt.pathspec);
|
2007-11-03 14:12:17 +01:00
|
|
|
|
2013-01-15 06:47:44 +01:00
|
|
|
return 0;
|
2007-09-11 05:19:34 +02:00
|
|
|
}
|
|
|
|
|
|
reset: give better reflog messages
The reset command creates its reflog entry from argv.
However, it does so after having run parse_options, which
means the only thing left in argv is any non-option
arguments. Thus you would end up with confusing reflog
entries like:
$ git reset --hard HEAD^
$ git reset --soft HEAD@{1}
$ git log -2 -g --oneline
8e46cad HEAD@{0}: HEAD@{1}: updating HEAD
1eb9486 HEAD@{1}: HEAD^: updating HEAD
However, we must also consider that some scripts may set
GIT_REFLOG_ACTION before calling reset, and we need to show
their reflog action (with our text appended). For example:
rebase -i (squash): updating HEAD
On top of that, we also set the ORIG_HEAD reflog action
(even though it doesn't generally exist). In that case, the
reset argument is somewhat meaningless, as it has nothing to
do with what's in ORIG_HEAD.
This patch changes the reset reflog code to show:
$GIT_REFLOG_ACTION: updating {HEAD,ORIG_HEAD}
as before, but only if GIT_REFLOG_ACTION is set. Otherwise,
show:
reset: moving to $rev
for HEAD, and:
reset: updating ORIG_HEAD
for ORIG_HEAD (this is still somewhat superfluous, since we
are in the ORIG_HEAD reflog, obviously, but at least we now
mention which command was used to update it).
While we're at it, we can clean up the code a bit:
- Use strbufs to make the message.
- Use the "rev" parameter instead of showing all options.
This makes more sense, since it is the only thing
impacting the writing of the ref.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-07-22 18:12:23 +02:00
|
|
|
static void set_reflog_message(struct strbuf *sb, const char *action,
|
|
|
|
|
const char *rev)
|
2007-09-11 05:19:34 +02:00
|
|
|
{
|
|
|
|
|
const char *rla = getenv("GIT_REFLOG_ACTION");
|
reset: give better reflog messages
The reset command creates its reflog entry from argv.
However, it does so after having run parse_options, which
means the only thing left in argv is any non-option
arguments. Thus you would end up with confusing reflog
entries like:
$ git reset --hard HEAD^
$ git reset --soft HEAD@{1}
$ git log -2 -g --oneline
8e46cad HEAD@{0}: HEAD@{1}: updating HEAD
1eb9486 HEAD@{1}: HEAD^: updating HEAD
However, we must also consider that some scripts may set
GIT_REFLOG_ACTION before calling reset, and we need to show
their reflog action (with our text appended). For example:
rebase -i (squash): updating HEAD
On top of that, we also set the ORIG_HEAD reflog action
(even though it doesn't generally exist). In that case, the
reset argument is somewhat meaningless, as it has nothing to
do with what's in ORIG_HEAD.
This patch changes the reset reflog code to show:
$GIT_REFLOG_ACTION: updating {HEAD,ORIG_HEAD}
as before, but only if GIT_REFLOG_ACTION is set. Otherwise,
show:
reset: moving to $rev
for HEAD, and:
reset: updating ORIG_HEAD
for ORIG_HEAD (this is still somewhat superfluous, since we
are in the ORIG_HEAD reflog, obviously, but at least we now
mention which command was used to update it).
While we're at it, we can clean up the code a bit:
- Use strbufs to make the message.
- Use the "rev" parameter instead of showing all options.
This makes more sense, since it is the only thing
impacting the writing of the ref.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-07-22 18:12:23 +02:00
|
|
|
|
|
|
|
|
strbuf_reset(sb);
|
|
|
|
|
if (rla)
|
|
|
|
|
strbuf_addf(sb, "%s: %s", rla, action);
|
|
|
|
|
else if (rev)
|
|
|
|
|
strbuf_addf(sb, "reset: moving to %s", rev);
|
|
|
|
|
else
|
|
|
|
|
strbuf_addf(sb, "reset: %s", action);
|
2007-09-11 05:19:34 +02:00
|
|
|
}
|
|
|
|
|
|
2010-01-19 05:26:01 +01:00
|
|
|
static void die_if_unmerged_cache(int reset_type)
|
|
|
|
|
{
|
|
|
|
|
if (is_merge() || read_cache() < 0 || unmerged_cache())
|
2011-02-23 00:42:07 +01:00
|
|
|
die(_("Cannot do a %s reset in the middle of a merge."),
|
|
|
|
|
_(reset_type_names[reset_type]));
|
2010-01-19 05:26:01 +01:00
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-14 10:35:47 +02:00
|
|
|
static void parse_args(struct pathspec *pathspec,
|
|
|
|
|
const char **argv, const char *prefix,
|
|
|
|
|
int patch_mode,
|
|
|
|
|
const char **rev_ret)
|
2007-09-11 05:19:34 +02:00
|
|
|
{
|
|
|
|
|
const char *rev = "HEAD";
|
2013-01-15 06:47:37 +01:00
|
|
|
unsigned char unused[20];
|
Allow "git-reset path" when unambiguous
Resetting a selected set of index entries is done with
"git reset -- paths" syntax, but we did not allow -- to be omitted
even when the command is unambiguous.
This updates the command to follow the general rule:
* When -- appears, revs come before it, and paths come after it;
* When there is no --, earlier ones are revs and the rest are paths, and
we need to guess. When lack of -- marker forces us to guess, we
protect from user errors and typoes by making sure what we treat as
revs do not appear as filenames in the work tree, and what we treat as
paths do appear as filenames in the work tree, and by erroring out if
that is not the case. We tell the user to disambiguate by using -- in
such a case.
which is employed elsewhere in the system.
When this rule is applied to "reset", because we can have only zero or one
rev to the command, the check can be slightly simpler than other programs.
We have to check only the first one or two tokens after the command name
and options, and when they are:
-- A:
no explicit rev given; "A" and whatever follows it are paths.
A --:
explicit rev "A" given and whatever follows the "--" are paths.
A B:
"A" could be rev or path and we need to guess. "B" could
be missing but if exists that (and everything that follows) would
be paths.
So we apply the guess only in the last case and only to "A" (not "B" and
what comes after it).
* As long as "A" is unambiguously a path, index entries for "A", "B" (and
everything that follows) are reset to the HEAD revision.
* If "A" is unambiguously a rev, on the other hand, the index entries for
"B" (and everything that follows) are reset to the "A" revision.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-26 03:16:36 +02:00
|
|
|
/*
|
|
|
|
|
* Possible arguments are:
|
|
|
|
|
*
|
2013-01-15 06:47:49 +01:00
|
|
|
* git reset [-opts] [<rev>]
|
|
|
|
|
* git reset [-opts] <tree> [<paths>...]
|
|
|
|
|
* git reset [-opts] <tree> -- [<paths>...]
|
|
|
|
|
* git reset [-opts] -- [<paths>...]
|
Allow "git-reset path" when unambiguous
Resetting a selected set of index entries is done with
"git reset -- paths" syntax, but we did not allow -- to be omitted
even when the command is unambiguous.
This updates the command to follow the general rule:
* When -- appears, revs come before it, and paths come after it;
* When there is no --, earlier ones are revs and the rest are paths, and
we need to guess. When lack of -- marker forces us to guess, we
protect from user errors and typoes by making sure what we treat as
revs do not appear as filenames in the work tree, and what we treat as
paths do appear as filenames in the work tree, and by erroring out if
that is not the case. We tell the user to disambiguate by using -- in
such a case.
which is employed elsewhere in the system.
When this rule is applied to "reset", because we can have only zero or one
rev to the command, the check can be slightly simpler than other programs.
We have to check only the first one or two tokens after the command name
and options, and when they are:
-- A:
no explicit rev given; "A" and whatever follows it are paths.
A --:
explicit rev "A" given and whatever follows the "--" are paths.
A B:
"A" could be rev or path and we need to guess. "B" could
be missing but if exists that (and everything that follows) would
be paths.
So we apply the guess only in the last case and only to "A" (not "B" and
what comes after it).
* As long as "A" is unambiguously a path, index entries for "A", "B" (and
everything that follows) are reset to the HEAD revision.
* If "A" is unambiguously a rev, on the other hand, the index entries for
"B" (and everything that follows) are reset to the "A" revision.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-26 03:16:36 +02:00
|
|
|
* git reset [-opts] <paths>...
|
|
|
|
|
*
|
2013-01-15 06:47:38 +01:00
|
|
|
* At this point, argv points immediately after [-opts].
|
Allow "git-reset path" when unambiguous
Resetting a selected set of index entries is done with
"git reset -- paths" syntax, but we did not allow -- to be omitted
even when the command is unambiguous.
This updates the command to follow the general rule:
* When -- appears, revs come before it, and paths come after it;
* When there is no --, earlier ones are revs and the rest are paths, and
we need to guess. When lack of -- marker forces us to guess, we
protect from user errors and typoes by making sure what we treat as
revs do not appear as filenames in the work tree, and what we treat as
paths do appear as filenames in the work tree, and by erroring out if
that is not the case. We tell the user to disambiguate by using -- in
such a case.
which is employed elsewhere in the system.
When this rule is applied to "reset", because we can have only zero or one
rev to the command, the check can be slightly simpler than other programs.
We have to check only the first one or two tokens after the command name
and options, and when they are:
-- A:
no explicit rev given; "A" and whatever follows it are paths.
A --:
explicit rev "A" given and whatever follows the "--" are paths.
A B:
"A" could be rev or path and we need to guess. "B" could
be missing but if exists that (and everything that follows) would
be paths.
So we apply the guess only in the last case and only to "A" (not "B" and
what comes after it).
* As long as "A" is unambiguously a path, index entries for "A", "B" (and
everything that follows) are reset to the HEAD revision.
* If "A" is unambiguously a rev, on the other hand, the index entries for
"B" (and everything that follows) are reset to the "A" revision.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-26 03:16:36 +02:00
|
|
|
*/
|
|
|
|
|
|
2013-01-15 06:47:38 +01:00
|
|
|
if (argv[0]) {
|
|
|
|
|
if (!strcmp(argv[0], "--")) {
|
|
|
|
|
argv++; /* reset to HEAD, possibly with paths */
|
|
|
|
|
} else if (argv[1] && !strcmp(argv[1], "--")) {
|
|
|
|
|
rev = argv[0];
|
|
|
|
|
argv += 2;
|
Allow "git-reset path" when unambiguous
Resetting a selected set of index entries is done with
"git reset -- paths" syntax, but we did not allow -- to be omitted
even when the command is unambiguous.
This updates the command to follow the general rule:
* When -- appears, revs come before it, and paths come after it;
* When there is no --, earlier ones are revs and the rest are paths, and
we need to guess. When lack of -- marker forces us to guess, we
protect from user errors and typoes by making sure what we treat as
revs do not appear as filenames in the work tree, and what we treat as
paths do appear as filenames in the work tree, and by erroring out if
that is not the case. We tell the user to disambiguate by using -- in
such a case.
which is employed elsewhere in the system.
When this rule is applied to "reset", because we can have only zero or one
rev to the command, the check can be slightly simpler than other programs.
We have to check only the first one or two tokens after the command name
and options, and when they are:
-- A:
no explicit rev given; "A" and whatever follows it are paths.
A --:
explicit rev "A" given and whatever follows the "--" are paths.
A B:
"A" could be rev or path and we need to guess. "B" could
be missing but if exists that (and everything that follows) would
be paths.
So we apply the guess only in the last case and only to "A" (not "B" and
what comes after it).
* As long as "A" is unambiguously a path, index entries for "A", "B" (and
everything that follows) are reset to the HEAD revision.
* If "A" is unambiguously a rev, on the other hand, the index entries for
"B" (and everything that follows) are reset to the "A" revision.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-26 03:16:36 +02:00
|
|
|
}
|
|
|
|
|
/*
|
2013-01-15 06:47:38 +01:00
|
|
|
* Otherwise, argv[0] could be either <rev> or <paths> and
|
2013-01-15 06:47:49 +01:00
|
|
|
* has to be unambiguous. If there is a single argument, it
|
|
|
|
|
* can not be a tree
|
Allow "git-reset path" when unambiguous
Resetting a selected set of index entries is done with
"git reset -- paths" syntax, but we did not allow -- to be omitted
even when the command is unambiguous.
This updates the command to follow the general rule:
* When -- appears, revs come before it, and paths come after it;
* When there is no --, earlier ones are revs and the rest are paths, and
we need to guess. When lack of -- marker forces us to guess, we
protect from user errors and typoes by making sure what we treat as
revs do not appear as filenames in the work tree, and what we treat as
paths do appear as filenames in the work tree, and by erroring out if
that is not the case. We tell the user to disambiguate by using -- in
such a case.
which is employed elsewhere in the system.
When this rule is applied to "reset", because we can have only zero or one
rev to the command, the check can be slightly simpler than other programs.
We have to check only the first one or two tokens after the command name
and options, and when they are:
-- A:
no explicit rev given; "A" and whatever follows it are paths.
A --:
explicit rev "A" given and whatever follows the "--" are paths.
A B:
"A" could be rev or path and we need to guess. "B" could
be missing but if exists that (and everything that follows) would
be paths.
So we apply the guess only in the last case and only to "A" (not "B" and
what comes after it).
* As long as "A" is unambiguously a path, index entries for "A", "B" (and
everything that follows) are reset to the HEAD revision.
* If "A" is unambiguously a rev, on the other hand, the index entries for
"B" (and everything that follows) are reset to the "A" revision.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-26 03:16:36 +02:00
|
|
|
*/
|
2013-01-15 06:47:49 +01:00
|
|
|
else if ((!argv[1] && !get_sha1_committish(argv[0], unused)) ||
|
|
|
|
|
(argv[1] && !get_sha1_treeish(argv[0], unused))) {
|
Allow "git-reset path" when unambiguous
Resetting a selected set of index entries is done with
"git reset -- paths" syntax, but we did not allow -- to be omitted
even when the command is unambiguous.
This updates the command to follow the general rule:
* When -- appears, revs come before it, and paths come after it;
* When there is no --, earlier ones are revs and the rest are paths, and
we need to guess. When lack of -- marker forces us to guess, we
protect from user errors and typoes by making sure what we treat as
revs do not appear as filenames in the work tree, and what we treat as
paths do appear as filenames in the work tree, and by erroring out if
that is not the case. We tell the user to disambiguate by using -- in
such a case.
which is employed elsewhere in the system.
When this rule is applied to "reset", because we can have only zero or one
rev to the command, the check can be slightly simpler than other programs.
We have to check only the first one or two tokens after the command name
and options, and when they are:
-- A:
no explicit rev given; "A" and whatever follows it are paths.
A --:
explicit rev "A" given and whatever follows the "--" are paths.
A B:
"A" could be rev or path and we need to guess. "B" could
be missing but if exists that (and everything that follows) would
be paths.
So we apply the guess only in the last case and only to "A" (not "B" and
what comes after it).
* As long as "A" is unambiguously a path, index entries for "A", "B" (and
everything that follows) are reset to the HEAD revision.
* If "A" is unambiguously a rev, on the other hand, the index entries for
"B" (and everything that follows) are reset to the "A" revision.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-26 03:16:36 +02:00
|
|
|
/*
|
2013-01-15 06:47:49 +01:00
|
|
|
* Ok, argv[0] looks like a commit/tree; it should not
|
Allow "git-reset path" when unambiguous
Resetting a selected set of index entries is done with
"git reset -- paths" syntax, but we did not allow -- to be omitted
even when the command is unambiguous.
This updates the command to follow the general rule:
* When -- appears, revs come before it, and paths come after it;
* When there is no --, earlier ones are revs and the rest are paths, and
we need to guess. When lack of -- marker forces us to guess, we
protect from user errors and typoes by making sure what we treat as
revs do not appear as filenames in the work tree, and what we treat as
paths do appear as filenames in the work tree, and by erroring out if
that is not the case. We tell the user to disambiguate by using -- in
such a case.
which is employed elsewhere in the system.
When this rule is applied to "reset", because we can have only zero or one
rev to the command, the check can be slightly simpler than other programs.
We have to check only the first one or two tokens after the command name
and options, and when they are:
-- A:
no explicit rev given; "A" and whatever follows it are paths.
A --:
explicit rev "A" given and whatever follows the "--" are paths.
A B:
"A" could be rev or path and we need to guess. "B" could
be missing but if exists that (and everything that follows) would
be paths.
So we apply the guess only in the last case and only to "A" (not "B" and
what comes after it).
* As long as "A" is unambiguously a path, index entries for "A", "B" (and
everything that follows) are reset to the HEAD revision.
* If "A" is unambiguously a rev, on the other hand, the index entries for
"B" (and everything that follows) are reset to the "A" revision.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-26 03:16:36 +02:00
|
|
|
* be a filename.
|
|
|
|
|
*/
|
2013-01-15 06:47:38 +01:00
|
|
|
verify_non_filename(prefix, argv[0]);
|
|
|
|
|
rev = *argv++;
|
Allow "git-reset path" when unambiguous
Resetting a selected set of index entries is done with
"git reset -- paths" syntax, but we did not allow -- to be omitted
even when the command is unambiguous.
This updates the command to follow the general rule:
* When -- appears, revs come before it, and paths come after it;
* When there is no --, earlier ones are revs and the rest are paths, and
we need to guess. When lack of -- marker forces us to guess, we
protect from user errors and typoes by making sure what we treat as
revs do not appear as filenames in the work tree, and what we treat as
paths do appear as filenames in the work tree, and by erroring out if
that is not the case. We tell the user to disambiguate by using -- in
such a case.
which is employed elsewhere in the system.
When this rule is applied to "reset", because we can have only zero or one
rev to the command, the check can be slightly simpler than other programs.
We have to check only the first one or two tokens after the command name
and options, and when they are:
-- A:
no explicit rev given; "A" and whatever follows it are paths.
A --:
explicit rev "A" given and whatever follows the "--" are paths.
A B:
"A" could be rev or path and we need to guess. "B" could
be missing but if exists that (and everything that follows) would
be paths.
So we apply the guess only in the last case and only to "A" (not "B" and
what comes after it).
* As long as "A" is unambiguously a path, index entries for "A", "B" (and
everything that follows) are reset to the HEAD revision.
* If "A" is unambiguously a rev, on the other hand, the index entries for
"B" (and everything that follows) are reset to the "A" revision.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-26 03:16:36 +02:00
|
|
|
} else {
|
|
|
|
|
/* Otherwise we treat this as a filename */
|
2013-01-15 06:47:38 +01:00
|
|
|
verify_filename(prefix, argv[0], 1);
|
Allow "git-reset path" when unambiguous
Resetting a selected set of index entries is done with
"git reset -- paths" syntax, but we did not allow -- to be omitted
even when the command is unambiguous.
This updates the command to follow the general rule:
* When -- appears, revs come before it, and paths come after it;
* When there is no --, earlier ones are revs and the rest are paths, and
we need to guess. When lack of -- marker forces us to guess, we
protect from user errors and typoes by making sure what we treat as
revs do not appear as filenames in the work tree, and what we treat as
paths do appear as filenames in the work tree, and by erroring out if
that is not the case. We tell the user to disambiguate by using -- in
such a case.
which is employed elsewhere in the system.
When this rule is applied to "reset", because we can have only zero or one
rev to the command, the check can be slightly simpler than other programs.
We have to check only the first one or two tokens after the command name
and options, and when they are:
-- A:
no explicit rev given; "A" and whatever follows it are paths.
A --:
explicit rev "A" given and whatever follows the "--" are paths.
A B:
"A" could be rev or path and we need to guess. "B" could
be missing but if exists that (and everything that follows) would
be paths.
So we apply the guess only in the last case and only to "A" (not "B" and
what comes after it).
* As long as "A" is unambiguously a path, index entries for "A", "B" (and
everything that follows) are reset to the HEAD revision.
* If "A" is unambiguously a rev, on the other hand, the index entries for
"B" (and everything that follows) are reset to the "A" revision.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-26 03:16:36 +02:00
|
|
|
}
|
|
|
|
|
}
|
2013-01-15 06:47:37 +01:00
|
|
|
*rev_ret = rev;
|
2013-07-14 10:35:50 +02:00
|
|
|
parse_pathspec(pathspec, 0,
|
|
|
|
|
PATHSPEC_PREFER_FULL |
|
|
|
|
|
(patch_mode ? PATHSPEC_PREFIX_ORIGIN : 0),
|
2013-07-14 10:35:47 +02:00
|
|
|
prefix, argv);
|
2013-01-15 06:47:37 +01:00
|
|
|
}
|
|
|
|
|
|
2013-01-15 06:47:39 +01:00
|
|
|
static int update_refs(const char *rev, const unsigned char *sha1)
|
|
|
|
|
{
|
|
|
|
|
int update_ref_status;
|
|
|
|
|
struct strbuf msg = STRBUF_INIT;
|
|
|
|
|
unsigned char *orig = NULL, sha1_orig[20],
|
|
|
|
|
*old_orig = NULL, sha1_old_orig[20];
|
|
|
|
|
|
|
|
|
|
if (!get_sha1("ORIG_HEAD", sha1_old_orig))
|
|
|
|
|
old_orig = sha1_old_orig;
|
|
|
|
|
if (!get_sha1("HEAD", sha1_orig)) {
|
|
|
|
|
orig = sha1_orig;
|
|
|
|
|
set_reflog_message(&msg, "updating ORIG_HEAD", NULL);
|
|
|
|
|
update_ref(msg.buf, "ORIG_HEAD", orig, old_orig, 0, MSG_ON_ERR);
|
|
|
|
|
} else if (old_orig)
|
|
|
|
|
delete_ref("ORIG_HEAD", old_orig, 0);
|
|
|
|
|
set_reflog_message(&msg, "updating HEAD", rev);
|
|
|
|
|
update_ref_status = update_ref(msg.buf, "HEAD", sha1, orig, 0, MSG_ON_ERR);
|
|
|
|
|
strbuf_release(&msg);
|
|
|
|
|
return update_ref_status;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-15 06:47:37 +01:00
|
|
|
int cmd_reset(int argc, const char **argv, const char *prefix)
|
|
|
|
|
{
|
|
|
|
|
int reset_type = NONE, update_ref_status = 0, quiet = 0;
|
2013-01-15 06:47:50 +01:00
|
|
|
int patch_mode = 0, unborn;
|
2013-01-15 06:47:37 +01:00
|
|
|
const char *rev;
|
2013-01-15 06:47:39 +01:00
|
|
|
unsigned char sha1[20];
|
2013-07-14 10:35:47 +02:00
|
|
|
struct pathspec pathspec;
|
2013-01-15 06:47:37 +01:00
|
|
|
const struct option options[] = {
|
|
|
|
|
OPT__QUIET(&quiet, N_("be quiet, only report errors")),
|
|
|
|
|
OPT_SET_INT(0, "mixed", &reset_type,
|
|
|
|
|
N_("reset HEAD and index"), MIXED),
|
|
|
|
|
OPT_SET_INT(0, "soft", &reset_type, N_("reset only HEAD"), SOFT),
|
|
|
|
|
OPT_SET_INT(0, "hard", &reset_type,
|
|
|
|
|
N_("reset HEAD, index and working tree"), HARD),
|
|
|
|
|
OPT_SET_INT(0, "merge", &reset_type,
|
|
|
|
|
N_("reset HEAD, index and working tree"), MERGE),
|
|
|
|
|
OPT_SET_INT(0, "keep", &reset_type,
|
|
|
|
|
N_("reset HEAD but keep local changes"), KEEP),
|
|
|
|
|
OPT_BOOLEAN('p', "patch", &patch_mode, N_("select hunks interactively")),
|
|
|
|
|
OPT_END()
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
git_config(git_default_config, NULL);
|
|
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, options, git_reset_usage,
|
|
|
|
|
PARSE_OPT_KEEP_DASHDASH);
|
2013-07-14 10:35:47 +02:00
|
|
|
parse_args(&pathspec, argv, prefix, patch_mode, &rev);
|
2007-09-11 05:19:34 +02:00
|
|
|
|
2013-01-15 06:47:50 +01:00
|
|
|
unborn = !strcmp(rev, "HEAD") && get_sha1("HEAD", sha1);
|
|
|
|
|
if (unborn) {
|
|
|
|
|
/* reset on unborn branch: treat as reset to empty tree */
|
|
|
|
|
hashcpy(sha1, EMPTY_TREE_SHA1_BIN);
|
2013-07-14 10:35:47 +02:00
|
|
|
} else if (!pathspec.nr) {
|
2013-01-15 06:47:49 +01:00
|
|
|
struct commit *commit;
|
|
|
|
|
if (get_sha1_committish(rev, sha1))
|
|
|
|
|
die(_("Failed to resolve '%s' as a valid revision."), rev);
|
|
|
|
|
commit = lookup_commit_reference(sha1);
|
|
|
|
|
if (!commit)
|
|
|
|
|
die(_("Could not parse object '%s'."), rev);
|
|
|
|
|
hashcpy(sha1, commit->object.sha1);
|
|
|
|
|
} else {
|
|
|
|
|
struct tree *tree;
|
|
|
|
|
if (get_sha1_treeish(rev, sha1))
|
|
|
|
|
die(_("Failed to resolve '%s' as a valid tree."), rev);
|
|
|
|
|
tree = parse_tree_indirect(sha1);
|
|
|
|
|
if (!tree)
|
|
|
|
|
die(_("Could not parse object '%s'."), rev);
|
|
|
|
|
hashcpy(sha1, tree->object.sha1);
|
|
|
|
|
}
|
2007-09-11 05:19:34 +02:00
|
|
|
|
2009-08-15 13:48:31 +02:00
|
|
|
if (patch_mode) {
|
|
|
|
|
if (reset_type != NONE)
|
2011-02-23 00:42:06 +01:00
|
|
|
die(_("--patch is incompatible with --{hard,mixed,soft}"));
|
2013-07-14 10:35:50 +02:00
|
|
|
return run_add_interactive(sha1_to_hex(sha1), "--patch=reset", &pathspec);
|
2009-08-15 13:48:31 +02:00
|
|
|
}
|
|
|
|
|
|
2007-09-11 05:19:34 +02:00
|
|
|
/* git reset tree [--] paths... can be used to
|
|
|
|
|
* load chosen paths from the tree into the index without
|
|
|
|
|
* affecting the working tree nor HEAD. */
|
2013-07-14 10:35:47 +02:00
|
|
|
if (pathspec.nr) {
|
2007-09-11 05:19:34 +02:00
|
|
|
if (reset_type == MIXED)
|
2011-02-23 00:42:06 +01:00
|
|
|
warning(_("--mixed with paths is deprecated; use 'git reset -- <paths>' instead."));
|
2007-09-11 05:19:34 +02:00
|
|
|
else if (reset_type != NONE)
|
2011-02-23 00:42:07 +01:00
|
|
|
die(_("Cannot do %s reset with paths."),
|
|
|
|
|
_(reset_type_names[reset_type]));
|
2007-09-11 05:19:34 +02:00
|
|
|
}
|
|
|
|
|
if (reset_type == NONE)
|
|
|
|
|
reset_type = MIXED; /* by default */
|
|
|
|
|
|
2010-01-19 05:26:00 +01:00
|
|
|
if (reset_type != SOFT && reset_type != MIXED)
|
2009-12-30 09:47:03 +01:00
|
|
|
setup_work_tree();
|
2007-12-31 08:13:52 +01:00
|
|
|
|
2009-12-30 06:54:44 +01:00
|
|
|
if (reset_type == MIXED && is_bare_repository())
|
2011-02-23 00:42:07 +01:00
|
|
|
die(_("%s reset is not allowed in a bare repository"),
|
|
|
|
|
_(reset_type_names[reset_type]));
|
2009-12-30 06:54:44 +01:00
|
|
|
|
2007-09-11 05:19:34 +02:00
|
|
|
/* Soft reset does not touch the index file nor the working tree
|
|
|
|
|
* at all, but requires them in a good order. Other resets reset
|
|
|
|
|
* the index file to the tree object we are switching to. */
|
2013-01-15 06:47:40 +01:00
|
|
|
if (reset_type == SOFT || reset_type == KEEP)
|
2010-01-19 05:26:01 +01:00
|
|
|
die_if_unmerged_cache(reset_type);
|
2013-01-15 06:47:40 +01:00
|
|
|
|
|
|
|
|
if (reset_type != SOFT) {
|
reset --keep: only write index file once
"git reset --keep" calls reset_index_file() twice, first doing a
two-way merge to the target revision, updating the index and worktree,
and then resetting the index. After each call, we write the index
file.
In the unlikely event that the second call to reset_index_file()
fails, the index will have been merged to the target revision, but
HEAD will not be updated, leaving the user with a dirty index.
By moving the locking, writing and committing out of
reset_index_file() and into the caller, we can avoid writing the index
twice, thereby making the sure we don't end up in the half-way reset
state. As a bonus, we speed up "git reset --keep" a little on the
linux-2.6 repo (best of five, warm cache):
Before After
real 0m0.315s 0m0.296s
user 0m0.290s 0m0.280s
sys 0m0.020s 0m0.010s
Signed-off-by: Martin von Zweigbergk <martinvonz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-15 06:47:41 +01:00
|
|
|
struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
|
|
|
|
|
int newfd = hold_locked_index(lock, 1);
|
2013-01-15 06:47:51 +01:00
|
|
|
if (reset_type == MIXED) {
|
2013-07-14 10:35:58 +02:00
|
|
|
if (read_from_tree(&pathspec, sha1))
|
2013-01-15 06:47:47 +01:00
|
|
|
return 1;
|
|
|
|
|
} else {
|
|
|
|
|
int err = reset_index(sha1, reset_type, quiet);
|
|
|
|
|
if (reset_type == KEEP && !err)
|
|
|
|
|
err = reset_index(sha1, MIXED, quiet);
|
|
|
|
|
if (err)
|
|
|
|
|
die(_("Could not reset index file to revision '%s'."), rev);
|
|
|
|
|
}
|
reset [--mixed]: only write index file once
When doing a mixed reset without paths, the index is locked, read,
reset, and written back as part of the actual reset operation (in
reset_index()). Then, when showing the list of worktree modifications,
we lock the index again, refresh it, and write it.
Change this so we only write the index once, making "git reset" a
little faster. It does mean that the index lock will be held a little
longer, but the difference is small compared to the time spent
refreshing the index.
There is one minor functional difference: We used to say "Could not
write new index file." if the first write failed, and "Could not
refresh index" if the second write failed. Now, we will only use the
first message.
This speeds up "git reset" a little on the linux-2.6 repo (best of
five, warm cache):
Before After
real 0m0.239s 0m0.214s
user 0m0.160s 0m0.130s
sys 0m0.070s 0m0.080s
Signed-off-by: Martin von Zweigbergk <martinvonz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-15 06:47:46 +01:00
|
|
|
|
2013-01-15 06:47:48 +01:00
|
|
|
if (reset_type == MIXED) { /* Report what has not been updated. */
|
|
|
|
|
int flags = quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN;
|
|
|
|
|
refresh_index(&the_index, flags, NULL, NULL,
|
|
|
|
|
_("Unstaged changes after reset:"));
|
|
|
|
|
}
|
reset [--mixed]: only write index file once
When doing a mixed reset without paths, the index is locked, read,
reset, and written back as part of the actual reset operation (in
reset_index()). Then, when showing the list of worktree modifications,
we lock the index again, refresh it, and write it.
Change this so we only write the index once, making "git reset" a
little faster. It does mean that the index lock will be held a little
longer, but the difference is small compared to the time spent
refreshing the index.
There is one minor functional difference: We used to say "Could not
write new index file." if the first write failed, and "Could not
refresh index" if the second write failed. Now, we will only use the
first message.
This speeds up "git reset" a little on the linux-2.6 repo (best of
five, warm cache):
Before After
real 0m0.239s 0m0.214s
user 0m0.160s 0m0.130s
sys 0m0.070s 0m0.080s
Signed-off-by: Martin von Zweigbergk <martinvonz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-15 06:47:46 +01:00
|
|
|
|
2013-01-15 06:47:42 +01:00
|
|
|
if (write_cache(newfd, active_cache, active_nr) ||
|
|
|
|
|
commit_locked_index(lock))
|
|
|
|
|
die(_("Could not write new index file."));
|
2007-09-11 05:19:34 +02:00
|
|
|
}
|
|
|
|
|
|
2013-07-14 10:35:47 +02:00
|
|
|
if (!pathspec.nr && !unborn) {
|
2013-01-15 06:47:47 +01:00
|
|
|
/* Any resets without paths update HEAD to the head being
|
|
|
|
|
* switched to, saving the previous head in ORIG_HEAD before. */
|
|
|
|
|
update_ref_status = update_refs(rev, sha1);
|
2007-09-11 05:19:34 +02:00
|
|
|
|
2013-01-15 06:47:47 +01:00
|
|
|
if (reset_type == HARD && !update_ref_status && !quiet)
|
2013-01-15 06:47:49 +01:00
|
|
|
print_new_head_line(lookup_commit_reference(sha1));
|
2013-01-15 06:47:47 +01:00
|
|
|
}
|
2013-07-14 10:35:47 +02:00
|
|
|
if (!pathspec.nr)
|
2013-01-15 06:47:50 +01:00
|
|
|
remove_branch_state();
|
2007-09-11 05:19:34 +02:00
|
|
|
|
|
|
|
|
return update_ref_status;
|
|
|
|
|
}
|