2007-09-11 03:19:34 +00: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
|
|
|
|
|
*/
|
|
|
|
|
#include "cache.h"
|
|
|
|
|
#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 16:40:16 +00:00
|
|
|
#include "branch.h"
|
2008-03-04 22:11:34 +00:00
|
|
|
#include "parse-options.h"
|
2009-12-30 05:54:47 +00:00
|
|
|
#include "unpack-trees.h"
|
|
|
|
|
#include "cache-tree.h"
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2008-03-04 22:11:34 +00:00
|
|
|
static const char * const git_reset_usage[] = {
|
2010-01-19 04:25:57 +00:00
|
|
|
"git reset [--mixed | --soft | --hard | --merge | --keep] [-q] [<commit>]",
|
2010-03-31 09:24:19 +00:00
|
|
|
"git reset [-q] <commit> [--] <paths>...",
|
|
|
|
|
"git reset --patch [<commit>] [--] [<paths>...]",
|
2008-03-04 22:11:34 +00:00
|
|
|
NULL
|
|
|
|
|
};
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2010-01-19 04:25:57 +00:00
|
|
|
enum reset_type { MIXED, SOFT, HARD, MERGE, KEEP, NONE };
|
|
|
|
|
static const char *reset_type_names[] = {
|
|
|
|
|
"mixed", "soft", "hard", "merge", "keep", NULL
|
|
|
|
|
};
|
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 17:30:31 +00:00
|
|
|
|
2007-09-11 03:19:34 +00:00
|
|
|
static char *args_to_str(const char **argv)
|
|
|
|
|
{
|
|
|
|
|
char *buf = NULL;
|
|
|
|
|
unsigned long len, space = 0, nr = 0;
|
|
|
|
|
|
|
|
|
|
for (; *argv; argv++) {
|
|
|
|
|
len = strlen(*argv);
|
|
|
|
|
ALLOC_GROW(buf, nr + 1 + len, space);
|
|
|
|
|
if (nr)
|
|
|
|
|
buf[nr++] = ' ';
|
|
|
|
|
memcpy(buf + nr, *argv, len);
|
|
|
|
|
nr += len;
|
|
|
|
|
}
|
|
|
|
|
ALLOC_GROW(buf, nr + 1, space);
|
|
|
|
|
buf[nr] = '\0';
|
|
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int is_merge(void)
|
|
|
|
|
{
|
|
|
|
|
return !access(git_path("MERGE_HEAD"), F_OK);
|
|
|
|
|
}
|
|
|
|
|
|
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 17:30:31 +00:00
|
|
|
static int reset_index_file(const unsigned char *sha1, int reset_type, int quiet)
|
2007-09-11 03:19:34 +00:00
|
|
|
{
|
2009-12-30 05:54:47 +00:00
|
|
|
int nr = 1;
|
|
|
|
|
int newfd;
|
|
|
|
|
struct tree_desc desc[2];
|
|
|
|
|
struct unpack_trees_options opts;
|
|
|
|
|
struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2009-12-30 05:54:47 +00: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 01:10:58 +00:00
|
|
|
if (!quiet)
|
2009-12-30 05:54:47 +00: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 17:30:31 +00:00
|
|
|
switch (reset_type) {
|
2010-01-19 04:25:57 +00: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 17:30:31 +00:00
|
|
|
case MERGE:
|
2009-12-30 05:54:47 +00: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 17:30:31 +00:00
|
|
|
break;
|
|
|
|
|
case HARD:
|
2009-12-30 05:54:47 +00: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 17:30:31 +00:00
|
|
|
/* fallthrough */
|
|
|
|
|
default:
|
2009-12-30 05:54:47 +00: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 17:30:31 +00:00
|
|
|
}
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2009-12-30 05:54:47 +00:00
|
|
|
newfd = hold_locked_index(lock, 1);
|
|
|
|
|
|
|
|
|
|
read_cache_unmerged();
|
|
|
|
|
|
2010-01-19 04:25:57 +00:00
|
|
|
if (reset_type == KEEP) {
|
|
|
|
|
unsigned char head_sha1[20];
|
|
|
|
|
if (get_sha1("HEAD", head_sha1))
|
|
|
|
|
return error("You do not have a valid HEAD.");
|
|
|
|
|
if (!fill_tree_descriptor(desc, head_sha1))
|
|
|
|
|
return error("Failed to find tree of HEAD.");
|
|
|
|
|
nr++;
|
|
|
|
|
opts.fn = twoway_merge;
|
|
|
|
|
}
|
|
|
|
|
|
2009-12-30 05:54:47 +00:00
|
|
|
if (!fill_tree_descriptor(desc + nr - 1, sha1))
|
|
|
|
|
return error("Failed to find tree of %s.", sha1_to_hex(sha1));
|
|
|
|
|
if (unpack_trees(nr, desc, &opts))
|
|
|
|
|
return -1;
|
|
|
|
|
if (write_cache(newfd, active_cache, active_nr) ||
|
|
|
|
|
commit_locked_index(lock))
|
|
|
|
|
return error("Could not write new index file.");
|
|
|
|
|
|
|
|
|
|
return 0;
|
2007-09-11 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void print_new_head_line(struct commit *commit)
|
|
|
|
|
{
|
2008-03-02 07:43:32 +00:00
|
|
|
const char *hex, *body;
|
2007-09-11 03:19:34 +00:00
|
|
|
|
|
|
|
|
hex = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV);
|
2008-03-02 07:43:32 +00:00
|
|
|
printf("HEAD is now at %s", hex);
|
2007-09-11 03:19:34 +00:00
|
|
|
body = strstr(commit->buffer, "\n\n");
|
|
|
|
|
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");
|
|
|
|
|
}
|
|
|
|
|
|
2008-07-25 20:49:08 +00:00
|
|
|
static int update_index_refresh(int fd, struct lock_file *index_lock, int flags)
|
2007-09-11 03:19:34 +00:00
|
|
|
{
|
2007-11-03 15:21:21 +00:00
|
|
|
int result;
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2007-11-03 15:21:21 +00:00
|
|
|
if (!index_lock) {
|
|
|
|
|
index_lock = xcalloc(1, sizeof(struct lock_file));
|
|
|
|
|
fd = hold_locked_index(index_lock, 1);
|
|
|
|
|
}
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2007-11-03 15:21:21 +00:00
|
|
|
if (read_cache() < 0)
|
|
|
|
|
return error("Could not read index");
|
2008-07-25 20:49:08 +00:00
|
|
|
|
2009-08-21 08:57:59 +00:00
|
|
|
result = refresh_index(&the_index, (flags), NULL, NULL,
|
|
|
|
|
"Unstaged changes after reset:") ? 1 : 0;
|
2007-11-03 15:21:21 +00:00
|
|
|
if (write_cache(fd, active_cache, active_nr) ||
|
|
|
|
|
commit_locked_index(index_lock))
|
|
|
|
|
return error ("Could not refresh index");
|
|
|
|
|
return result;
|
|
|
|
|
}
|
2007-11-03 13:12:17 +00:00
|
|
|
|
2007-09-11 03:19:34 +00:00
|
|
|
static void update_index_from_diff(struct diff_queue_struct *q,
|
|
|
|
|
struct diff_options *opt, void *data)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
2007-11-03 15:21:21 +00:00
|
|
|
int *discard_flag = data;
|
2007-09-11 03:19:34 +00:00
|
|
|
|
|
|
|
|
/* do_diff_cache() mangled the index */
|
|
|
|
|
discard_cache();
|
2007-11-03 15:21:21 +00:00
|
|
|
*discard_flag = 1;
|
2007-09-11 03:19:34 +00:00
|
|
|
read_cache();
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
|
struct diff_filespec *one = q->queue[i]->one;
|
|
|
|
|
if (one->mode) {
|
|
|
|
|
struct cache_entry *ce;
|
|
|
|
|
ce = make_cache_entry(one->mode, one->sha1, one->path,
|
|
|
|
|
0, 0);
|
2008-10-05 02:14:40 +00:00
|
|
|
if (!ce)
|
|
|
|
|
die("make_cache_entry failed for path '%s'",
|
|
|
|
|
one->path);
|
2007-09-11 03:19:34 +00:00
|
|
|
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD |
|
|
|
|
|
ADD_CACHE_OK_TO_REPLACE);
|
|
|
|
|
} else
|
|
|
|
|
remove_file_from_cache(one->path);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-15 11:48:31 +00:00
|
|
|
static int interactive_reset(const char *revision, const char **argv,
|
|
|
|
|
const char *prefix)
|
|
|
|
|
{
|
|
|
|
|
const char **pathspec = NULL;
|
|
|
|
|
|
|
|
|
|
if (*argv)
|
|
|
|
|
pathspec = get_pathspec(prefix, argv);
|
|
|
|
|
|
|
|
|
|
return run_add_interactive(revision, "--patch=reset", pathspec);
|
|
|
|
|
}
|
|
|
|
|
|
2007-09-11 03:19:34 +00:00
|
|
|
static int read_from_tree(const char *prefix, const char **argv,
|
2008-07-25 20:49:08 +00:00
|
|
|
unsigned char *tree_sha1, int refresh_flags)
|
2007-09-11 03:19:34 +00:00
|
|
|
{
|
2007-11-03 15:21:21 +00:00
|
|
|
struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
|
|
|
|
|
int index_fd, index_was_discarded = 0;
|
2007-09-11 03:19:34 +00:00
|
|
|
struct diff_options opt;
|
|
|
|
|
|
|
|
|
|
memset(&opt, 0, sizeof(opt));
|
|
|
|
|
diff_tree_setup_paths(get_pathspec(prefix, (const char **)argv), &opt);
|
|
|
|
|
opt.output_format = DIFF_FORMAT_CALLBACK;
|
|
|
|
|
opt.format_callback = update_index_from_diff;
|
2007-11-03 15:21:21 +00:00
|
|
|
opt.format_callback_data = &index_was_discarded;
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2007-11-03 15:21:21 +00:00
|
|
|
index_fd = hold_locked_index(lock, 1);
|
|
|
|
|
index_was_discarded = 0;
|
2007-09-11 03:19:34 +00:00
|
|
|
read_cache();
|
|
|
|
|
if (do_diff_cache(tree_sha1, &opt))
|
|
|
|
|
return 1;
|
|
|
|
|
diffcore_std(&opt);
|
|
|
|
|
diff_flush(&opt);
|
2007-12-11 21:59:55 +00:00
|
|
|
diff_tree_release_paths(&opt);
|
2007-11-03 13:12:17 +00:00
|
|
|
|
2007-11-03 15:21:21 +00:00
|
|
|
if (!index_was_discarded)
|
|
|
|
|
/* The index is still clobbered from do_diff_cache() */
|
|
|
|
|
discard_cache();
|
2008-07-25 20:49:08 +00:00
|
|
|
return update_index_refresh(index_fd, lock, refresh_flags);
|
2007-09-11 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void prepend_reflog_action(const char *action, char *buf, size_t size)
|
|
|
|
|
{
|
|
|
|
|
const char *sep = ": ";
|
|
|
|
|
const char *rla = getenv("GIT_REFLOG_ACTION");
|
|
|
|
|
if (!rla)
|
|
|
|
|
rla = sep = "";
|
|
|
|
|
if (snprintf(buf, size, "%s%s%s", rla, sep, action) >= size)
|
|
|
|
|
warning("Reflog action message too long: %.*s...", 50, buf);
|
|
|
|
|
}
|
|
|
|
|
|
2010-01-19 04:26:01 +00:00
|
|
|
static void die_if_unmerged_cache(int reset_type)
|
|
|
|
|
{
|
|
|
|
|
if (is_merge() || read_cache() < 0 || unmerged_cache())
|
|
|
|
|
die("Cannot do a %s reset in the middle of a merge.",
|
|
|
|
|
reset_type_names[reset_type]);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2007-09-11 03:19:34 +00:00
|
|
|
int cmd_reset(int argc, const char **argv, const char *prefix)
|
|
|
|
|
{
|
2008-03-04 22:11:34 +00:00
|
|
|
int i = 0, reset_type = NONE, update_ref_status = 0, quiet = 0;
|
2009-08-15 11:48:31 +00:00
|
|
|
int patch_mode = 0;
|
2007-09-11 03:19:34 +00:00
|
|
|
const char *rev = "HEAD";
|
|
|
|
|
unsigned char sha1[20], *orig = NULL, sha1_orig[20],
|
|
|
|
|
*old_orig = NULL, sha1_old_orig[20];
|
|
|
|
|
struct commit *commit;
|
|
|
|
|
char *reflog_action, msg[1024];
|
2008-03-04 22:11:34 +00:00
|
|
|
const struct option options[] = {
|
2009-12-02 21:28:40 +00:00
|
|
|
OPT__QUIET(&quiet),
|
2008-03-04 22:11:34 +00:00
|
|
|
OPT_SET_INT(0, "mixed", &reset_type,
|
|
|
|
|
"reset HEAD and index", MIXED),
|
|
|
|
|
OPT_SET_INT(0, "soft", &reset_type, "reset only HEAD", SOFT),
|
|
|
|
|
OPT_SET_INT(0, "hard", &reset_type,
|
|
|
|
|
"reset HEAD, index and working tree", HARD),
|
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 17:30:31 +00:00
|
|
|
OPT_SET_INT(0, "merge", &reset_type,
|
|
|
|
|
"reset HEAD, index and working tree", MERGE),
|
2010-01-19 04:25:57 +00:00
|
|
|
OPT_SET_INT(0, "keep", &reset_type,
|
|
|
|
|
"reset HEAD but keep local changes", KEEP),
|
2009-08-15 11:48:31 +00:00
|
|
|
OPT_BOOLEAN('p', "patch", &patch_mode, "select hunks interactively"),
|
2008-03-04 22:11:34 +00:00
|
|
|
OPT_END()
|
|
|
|
|
};
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_default_config, NULL);
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, options, git_reset_usage,
|
2008-03-04 22:11:34 +00:00
|
|
|
PARSE_OPT_KEEP_DASHDASH);
|
2007-09-11 03:19:34 +00:00
|
|
|
reflog_action = args_to_str(argv);
|
|
|
|
|
setenv("GIT_REFLOG_ACTION", reflog_action, 0);
|
|
|
|
|
|
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 01:16:36 +00:00
|
|
|
/*
|
|
|
|
|
* Possible arguments are:
|
|
|
|
|
*
|
|
|
|
|
* git reset [-opts] <rev> <paths>...
|
|
|
|
|
* git reset [-opts] <rev> -- <paths>...
|
|
|
|
|
* git reset [-opts] -- <paths>...
|
|
|
|
|
* git reset [-opts] <paths>...
|
|
|
|
|
*
|
|
|
|
|
* At this point, argv[i] points immediately after [-opts].
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (i < argc) {
|
|
|
|
|
if (!strcmp(argv[i], "--")) {
|
|
|
|
|
i++; /* reset to HEAD, possibly with paths */
|
|
|
|
|
} else if (i + 1 < argc && !strcmp(argv[i+1], "--")) {
|
|
|
|
|
rev = argv[i];
|
|
|
|
|
i += 2;
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* Otherwise, argv[i] could be either <rev> or <paths> and
|
2009-04-17 18:13:30 +00:00
|
|
|
* has to be unambiguous.
|
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 01:16:36 +00:00
|
|
|
*/
|
|
|
|
|
else if (!get_sha1(argv[i], sha1)) {
|
|
|
|
|
/*
|
|
|
|
|
* Ok, argv[i] looks like a rev; it should not
|
|
|
|
|
* be a filename.
|
|
|
|
|
*/
|
|
|
|
|
verify_non_filename(prefix, argv[i]);
|
|
|
|
|
rev = argv[i++];
|
|
|
|
|
} else {
|
|
|
|
|
/* Otherwise we treat this as a filename */
|
|
|
|
|
verify_filename(prefix, argv[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
2007-09-11 03:19:34 +00:00
|
|
|
|
|
|
|
|
if (get_sha1(rev, sha1))
|
|
|
|
|
die("Failed to resolve '%s' as a valid ref.", rev);
|
|
|
|
|
|
|
|
|
|
commit = lookup_commit_reference(sha1);
|
|
|
|
|
if (!commit)
|
|
|
|
|
die("Could not parse object '%s'.", rev);
|
|
|
|
|
hashcpy(sha1, commit->object.sha1);
|
|
|
|
|
|
2009-08-15 11:48:31 +00:00
|
|
|
if (patch_mode) {
|
|
|
|
|
if (reset_type != NONE)
|
|
|
|
|
die("--patch is incompatible with --{hard,mixed,soft}");
|
|
|
|
|
return interactive_reset(rev, argv + i, prefix);
|
|
|
|
|
}
|
|
|
|
|
|
2007-09-11 03:19:34 +00: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. */
|
|
|
|
|
if (i < argc) {
|
|
|
|
|
if (reset_type == MIXED)
|
|
|
|
|
warning("--mixed option is deprecated with paths.");
|
|
|
|
|
else if (reset_type != NONE)
|
|
|
|
|
die("Cannot do %s reset with paths.",
|
|
|
|
|
reset_type_names[reset_type]);
|
2008-07-25 20:49:08 +00:00
|
|
|
return read_from_tree(prefix, argv + i, sha1,
|
2009-08-21 08:57:58 +00:00
|
|
|
quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN);
|
2007-09-11 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
if (reset_type == NONE)
|
|
|
|
|
reset_type = MIXED; /* by default */
|
|
|
|
|
|
2010-01-19 04:26:00 +00:00
|
|
|
if (reset_type != SOFT && reset_type != MIXED)
|
2009-12-30 08:47:03 +00:00
|
|
|
setup_work_tree();
|
2007-12-31 07:13:52 +00:00
|
|
|
|
2009-12-30 05:54:44 +00:00
|
|
|
if (reset_type == MIXED && is_bare_repository())
|
|
|
|
|
die("%s reset is not allowed in a bare repository",
|
|
|
|
|
reset_type_names[reset_type]);
|
|
|
|
|
|
2007-09-11 03:19:34 +00: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. */
|
2010-01-19 04:26:01 +00:00
|
|
|
if (reset_type == SOFT)
|
|
|
|
|
die_if_unmerged_cache(reset_type);
|
|
|
|
|
else {
|
|
|
|
|
int err;
|
|
|
|
|
if (reset_type == KEEP)
|
|
|
|
|
die_if_unmerged_cache(reset_type);
|
|
|
|
|
err = reset_index_file(sha1, reset_type, quiet);
|
2010-01-19 04:25:57 +00:00
|
|
|
if (reset_type == KEEP)
|
|
|
|
|
err = err || reset_index_file(sha1, MIXED, quiet);
|
|
|
|
|
if (err)
|
|
|
|
|
die("Could not reset index file to revision '%s'.", rev);
|
2007-09-11 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Any resets update HEAD to the head being switched to,
|
|
|
|
|
* saving the previous head in ORIG_HEAD before. */
|
|
|
|
|
if (!get_sha1("ORIG_HEAD", sha1_old_orig))
|
|
|
|
|
old_orig = sha1_old_orig;
|
|
|
|
|
if (!get_sha1("HEAD", sha1_orig)) {
|
|
|
|
|
orig = sha1_orig;
|
|
|
|
|
prepend_reflog_action("updating ORIG_HEAD", msg, sizeof(msg));
|
|
|
|
|
update_ref(msg, "ORIG_HEAD", orig, old_orig, 0, MSG_ON_ERR);
|
|
|
|
|
}
|
|
|
|
|
else if (old_orig)
|
2008-10-26 02:33:56 +00:00
|
|
|
delete_ref("ORIG_HEAD", old_orig, 0);
|
2007-09-11 03:19:34 +00:00
|
|
|
prepend_reflog_action("updating HEAD", msg, sizeof(msg));
|
|
|
|
|
update_ref_status = update_ref(msg, "HEAD", sha1, orig, 0, MSG_ON_ERR);
|
|
|
|
|
|
|
|
|
|
switch (reset_type) {
|
|
|
|
|
case HARD:
|
2007-11-04 09:37:20 +00:00
|
|
|
if (!update_ref_status && !quiet)
|
2007-09-11 03:19:34 +00:00
|
|
|
print_new_head_line(commit);
|
|
|
|
|
break;
|
|
|
|
|
case SOFT: /* Nothing else to do. */
|
|
|
|
|
break;
|
|
|
|
|
case MIXED: /* Report what has not been updated. */
|
2008-07-25 20:49:08 +00:00
|
|
|
update_index_refresh(0, NULL,
|
2009-08-21 08:57:58 +00:00
|
|
|
quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN);
|
2007-09-11 03:19:34 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-07 16:40:16 +00:00
|
|
|
remove_branch_state();
|
2007-09-11 03:19:34 +00:00
|
|
|
|
|
|
|
|
free(reflog_action);
|
|
|
|
|
|
|
|
|
|
return update_ref_status;
|
|
|
|
|
}
|