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
|
|
|
|
|
*/
|
2019-01-24 08:29:12 +00:00
|
|
|
#define USE_THE_INDEX_COMPATIBILITY_MACROS
|
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 07:51:05 +00:00
|
|
|
#include "builtin.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2014-10-01 10:28:42 +00:00
|
|
|
#include "lockfile.h"
|
2007-09-11 03:19:34 +00:00
|
|
|
#include "tag.h"
|
|
|
|
|
#include "object.h"
|
2017-12-12 08:55:35 +00:00
|
|
|
#include "pretty.h"
|
2007-09-11 03:19:34 +00:00
|
|
|
#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"
|
2017-04-21 17:39:53 +00:00
|
|
|
#include "submodule.h"
|
|
|
|
|
#include "submodule-config.h"
|
|
|
|
|
|
2018-10-23 19:04:23 +00:00
|
|
|
#define REFRESH_INDEX_DELAY_WARNING_IN_MS (2 * 1000)
|
|
|
|
|
|
2008-03-04 22:11:34 +00:00
|
|
|
static const char * const git_reset_usage[] = {
|
2012-08-20 12:32:39 +00:00
|
|
|
N_("git reset [--mixed | --soft | --hard | --merge | --keep] [-q] [<commit>]"),
|
2019-11-19 16:48:52 +00:00
|
|
|
N_("git reset [-q] [<tree-ish>] [--] <pathspec>..."),
|
2019-11-19 16:48:53 +00:00
|
|
|
N_("git reset [-q] [--pathspec-from-file [--pathspec-file-nul]] [<tree-ish>]"),
|
2019-11-19 16:48:52 +00:00
|
|
|
N_("git reset --patch [<tree-ish>] [--] [<pathspec>...]"),
|
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[] = {
|
2011-02-22 23:42:07 +00:00
|
|
|
N_("mixed"), N_("soft"), N_("hard"), N_("merge"), N_("keep"), NULL
|
2010-01-19 04:25:57 +00: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 17:30:31 +00:00
|
|
|
|
2007-09-11 03:19:34 +00:00
|
|
|
static inline int is_merge(void)
|
|
|
|
|
{
|
2018-05-17 22:51:51 +00:00
|
|
|
return !access(git_path_merge_head(the_repository), F_OK);
|
2007-09-11 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
|
2020-03-16 18:05:07 +00:00
|
|
|
static int reset_index(const char *ref, const struct object_id *oid, int reset_type, int quiet)
|
2007-09-11 03:19:34 +00:00
|
|
|
{
|
2017-09-05 13:04:51 +00:00
|
|
|
int i, nr = 0;
|
2009-12-30 05:54:47 +00:00
|
|
|
struct tree_desc desc[2];
|
2011-12-06 17:43:39 +00:00
|
|
|
struct tree *tree;
|
2009-12-30 05:54:47 +00:00
|
|
|
struct unpack_trees_options opts;
|
2017-09-05 13:04:51 +00:00
|
|
|
int ret = -1;
|
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;
|
2020-03-16 18:05:07 +00:00
|
|
|
init_checkout_metadata(&opts.meta, ref, oid, NULL);
|
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;
|
2021-09-27 16:33:43 +00:00
|
|
|
opts.preserve_ignored = 0; /* FIXME: !overwrite_ignore */
|
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;
|
2021-09-27 16:33:44 +00:00
|
|
|
opts.reset = UNPACK_RESET_OVERWRITE_UNTRACKED;
|
|
|
|
|
break;
|
|
|
|
|
case MIXED:
|
|
|
|
|
opts.reset = UNPACK_RESET_PROTECT_UNTRACKED;
|
|
|
|
|
/* but opts.update=0, so working tree not updated */
|
|
|
|
|
break;
|
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
|
|
|
default:
|
2021-09-27 16:33:44 +00:00
|
|
|
BUG("invalid reset_type passed to reset_index");
|
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
|
|
|
read_cache_unmerged();
|
|
|
|
|
|
2010-01-19 04:25:57 +00:00
|
|
|
if (reset_type == KEEP) {
|
2016-09-05 20:08:11 +00:00
|
|
|
struct object_id head_oid;
|
|
|
|
|
if (get_oid("HEAD", &head_oid))
|
2011-02-22 23:42:06 +00:00
|
|
|
return error(_("You do not have a valid HEAD."));
|
2019-06-27 09:28:48 +00:00
|
|
|
if (!fill_tree_descriptor(the_repository, desc + nr, &head_oid))
|
2011-02-22 23:42:06 +00:00
|
|
|
return error(_("Failed to find tree of HEAD."));
|
2010-01-19 04:25:57 +00:00
|
|
|
nr++;
|
|
|
|
|
opts.fn = twoway_merge;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-27 09:28:48 +00:00
|
|
|
if (!fill_tree_descriptor(the_repository, desc + nr, oid)) {
|
2017-09-05 13:04:51 +00:00
|
|
|
error(_("Failed to find tree of %s."), oid_to_hex(oid));
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2017-09-05 13:04:28 +00:00
|
|
|
nr++;
|
|
|
|
|
|
2009-12-30 05:54:47 +00:00
|
|
|
if (unpack_trees(nr, desc, &opts))
|
2017-09-05 13:04:51 +00:00
|
|
|
goto out;
|
2011-12-06 17:43:39 +00:00
|
|
|
|
|
|
|
|
if (reset_type == MIXED || reset_type == HARD) {
|
2017-05-06 22:10:37 +00:00
|
|
|
tree = parse_tree_indirect(oid);
|
2018-11-10 05:49:02 +00:00
|
|
|
prime_cache_tree(the_repository, the_repository->index, tree);
|
2011-12-06 17:43:39 +00:00
|
|
|
}
|
|
|
|
|
|
2017-09-05 13:04:51 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
for (i = 0; i < nr; i++)
|
|
|
|
|
free((void *)desc[i].buffer);
|
|
|
|
|
return ret;
|
2007-09-11 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void print_new_head_line(struct commit *commit)
|
|
|
|
|
{
|
reset --hard: make use of the pretty machinery
reset --hard currently uses its own logic for printing the first line of
the commit message in its output. Instead of just using the first line,
use the pretty machinery to create the output.
In addition to the easier to follow code, this makes the output more
consistent with other commands that print the title of the commit, such
as 'git commit --oneline' or 'git checkout', which both use
'pp_commit_easy()' with the CMIT_FMT_ONELINE modifier.
It is a slight change of the output if the second line of the commit
message is not a blank line, i.e. if the commit message is
foo
bar
previously we would print "HEAD is now at 000000 foo", while after
this change we print "HEAD is now at 000000 foo bar", same as 'git log
--oneline' shows "000000 foo bar".
So this does make the output more consistent with other commands, and
'reset' is a porcelain command, so nobody should be parsing the output
in scripts.
The current behaviour dates back to 0e5a7faa3a ("Make "git reset" a
builtin.", 2007-09-11), so I assume (without digging into the old
codebase too much) that the logic was implemented because there was
no convenience function such as 'pp_commit_easy' that would do this
already.
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-01 20:57:21 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2007-09-11 03:19:34 +00:00
|
|
|
|
reset --hard: make use of the pretty machinery
reset --hard currently uses its own logic for printing the first line of
the commit message in its output. Instead of just using the first line,
use the pretty machinery to create the output.
In addition to the easier to follow code, this makes the output more
consistent with other commands that print the title of the commit, such
as 'git commit --oneline' or 'git checkout', which both use
'pp_commit_easy()' with the CMIT_FMT_ONELINE modifier.
It is a slight change of the output if the second line of the commit
message is not a blank line, i.e. if the commit message is
foo
bar
previously we would print "HEAD is now at 000000 foo", while after
this change we print "HEAD is now at 000000 foo bar", same as 'git log
--oneline' shows "000000 foo bar".
So this does make the output more consistent with other commands, and
'reset' is a porcelain command, so nobody should be parsing the output
in scripts.
The current behaviour dates back to 0e5a7faa3a ("Make "git reset" a
builtin.", 2007-09-11), so I assume (without digging into the old
codebase too much) that the logic was implemented because there was
no convenience function such as 'pp_commit_easy' that would do this
already.
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-01 20:57:21 +00:00
|
|
|
printf(_("HEAD is now at %s"),
|
2018-03-12 02:27:30 +00:00
|
|
|
find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV));
|
reset --hard: make use of the pretty machinery
reset --hard currently uses its own logic for printing the first line of
the commit message in its output. Instead of just using the first line,
use the pretty machinery to create the output.
In addition to the easier to follow code, this makes the output more
consistent with other commands that print the title of the commit, such
as 'git commit --oneline' or 'git checkout', which both use
'pp_commit_easy()' with the CMIT_FMT_ONELINE modifier.
It is a slight change of the output if the second line of the commit
message is not a blank line, i.e. if the commit message is
foo
bar
previously we would print "HEAD is now at 000000 foo", while after
this change we print "HEAD is now at 000000 foo bar", same as 'git log
--oneline' shows "000000 foo bar".
So this does make the output more consistent with other commands, and
'reset' is a porcelain command, so nobody should be parsing the output
in scripts.
The current behaviour dates back to 0e5a7faa3a ("Make "git reset" a
builtin.", 2007-09-11), so I assume (without digging into the old
codebase too much) that the logic was implemented because there was
no convenience function such as 'pp_commit_easy' that would do this
already.
Signed-off-by: Thomas Gummerer <t.gummerer@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-02-01 20:57:21 +00:00
|
|
|
|
|
|
|
|
pp_commit_easy(CMIT_FMT_ONELINE, commit, &buf);
|
|
|
|
|
if (buf.len > 0)
|
|
|
|
|
printf(" %s", buf.buf);
|
|
|
|
|
putchar('\n');
|
|
|
|
|
strbuf_release(&buf);
|
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;
|
2014-02-04 02:20:09 +00:00
|
|
|
int intent_to_add = *(int *)data;
|
2007-09-11 03:19:34 +00:00
|
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
|
struct diff_filespec *one = q->queue[i]->one;
|
2016-06-24 23:09:23 +00:00
|
|
|
int is_missing = !(one->mode && !is_null_oid(&one->oid));
|
2014-02-04 02:20:09 +00:00
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
|
|
|
|
if (is_missing && !intent_to_add) {
|
2007-09-11 03:19:34 +00:00
|
|
|
remove_file_from_cache(one->path);
|
2014-02-04 02:20:09 +00:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-02 19:49:31 +00:00
|
|
|
ce = make_cache_entry(&the_index, one->mode, &one->oid, one->path,
|
2014-02-04 02:20:09 +00:00
|
|
|
0, 0);
|
|
|
|
|
if (!ce)
|
|
|
|
|
die(_("make_cache_entry failed for path '%s'"),
|
|
|
|
|
one->path);
|
|
|
|
|
if (is_missing) {
|
|
|
|
|
ce->ce_flags |= CE_INTENT_TO_ADD;
|
|
|
|
|
set_object_name_for_intent_to_add_entry(ce);
|
|
|
|
|
}
|
|
|
|
|
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE);
|
2007-09-11 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-14 08:35:58 +00:00
|
|
|
static int read_from_tree(const struct pathspec *pathspec,
|
2016-09-05 20:08:11 +00:00
|
|
|
struct object_id *tree_oid,
|
2014-02-04 02:20:09 +00:00
|
|
|
int intent_to_add)
|
2007-09-11 03:19:34 +00:00
|
|
|
{
|
|
|
|
|
struct diff_options opt;
|
|
|
|
|
|
|
|
|
|
memset(&opt, 0, sizeof(opt));
|
2013-07-14 08:35:58 +00:00
|
|
|
copy_pathspec(&opt.pathspec, pathspec);
|
2007-09-11 03:19:34 +00:00
|
|
|
opt.output_format = DIFF_FORMAT_CALLBACK;
|
|
|
|
|
opt.format_callback = update_index_from_diff;
|
2014-02-04 02:20:09 +00:00
|
|
|
opt.format_callback_data = &intent_to_add;
|
2017-10-31 18:19:11 +00:00
|
|
|
opt.flags.override_submodule_config = 1;
|
2018-09-21 15:57:19 +00:00
|
|
|
opt.repo = the_repository;
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2017-05-06 22:10:35 +00:00
|
|
|
if (do_diff_cache(tree_oid, &opt))
|
2007-09-11 03:19:34 +00:00
|
|
|
return 1;
|
|
|
|
|
diffcore_std(&opt);
|
|
|
|
|
diff_flush(&opt);
|
2016-06-02 21:09:22 +00:00
|
|
|
clear_pathspec(&opt.pathspec);
|
2007-11-03 13:12:17 +00:00
|
|
|
|
2013-01-15 05:47:44 +00:00
|
|
|
return 0;
|
2007-09-11 03:19:34 +00: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 16:12:23 +00:00
|
|
|
static void set_reflog_message(struct strbuf *sb, const char *action,
|
|
|
|
|
const char *rev)
|
2007-09-11 03:19:34 +00: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 16:12:23 +00: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 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
|
2010-01-19 04:26:01 +00:00
|
|
|
static void die_if_unmerged_cache(int reset_type)
|
|
|
|
|
{
|
2013-09-12 19:25:01 +00:00
|
|
|
if (is_merge() || unmerged_cache())
|
2011-02-22 23:42:07 +00:00
|
|
|
die(_("Cannot do a %s reset in the middle of a merge."),
|
|
|
|
|
_(reset_type_names[reset_type]));
|
2010-01-19 04:26:01 +00:00
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-14 08:35:47 +00:00
|
|
|
static void parse_args(struct pathspec *pathspec,
|
|
|
|
|
const char **argv, const char *prefix,
|
|
|
|
|
int patch_mode,
|
|
|
|
|
const char **rev_ret)
|
2007-09-11 03:19:34 +00:00
|
|
|
{
|
|
|
|
|
const char *rev = "HEAD";
|
2016-09-05 20:08:11 +00:00
|
|
|
struct object_id 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 01:16:36 +00:00
|
|
|
/*
|
|
|
|
|
* Possible arguments are:
|
|
|
|
|
*
|
2013-01-15 05:47:49 +00: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 01:16:36 +00:00
|
|
|
* git reset [-opts] <paths>...
|
|
|
|
|
*
|
2013-01-15 05:47:38 +00: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 01:16:36 +00:00
|
|
|
*/
|
|
|
|
|
|
2013-01-15 05:47:38 +00: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 01:16:36 +00:00
|
|
|
}
|
|
|
|
|
/*
|
2013-01-15 05:47:38 +00:00
|
|
|
* Otherwise, argv[0] could be either <rev> or <paths> and
|
2013-01-15 05:47:49 +00: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 01:16:36 +00:00
|
|
|
*/
|
sha1_name: convert get_sha1* to get_oid*
Now that all the callers of get_sha1 directly or indirectly use struct
object_id, rename the functions starting with get_sha1 to start with
get_oid. Convert the internals in sha1_name.c to use struct object_id
as well, and eliminate explicit length checks where possible. Convert a
use of 40 in get_oid_basic to GIT_SHA1_HEXSZ.
Outside of sha1_name.c and cache.h, this transition was made with the
following semantic patch:
@@
expression E1, E2;
@@
- get_sha1(E1, E2.hash)
+ get_oid(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1(E1, E2->hash)
+ get_oid(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2.hash)
+ get_oid_committish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2->hash)
+ get_oid_committish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2.hash)
+ get_oid_treeish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2->hash)
+ get_oid_treeish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2.hash)
+ get_oid_commit(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2->hash)
+ get_oid_commit(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2.hash)
+ get_oid_tree(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2->hash)
+ get_oid_tree(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2.hash)
+ get_oid_blob(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2->hash)
+ get_oid_blob(E1, E2)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3.hash, E4)
+ get_oid_with_context(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3->hash, E4)
+ get_oid_with_context(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-07-13 23:49:28 +00:00
|
|
|
else if ((!argv[1] && !get_oid_committish(argv[0], &unused)) ||
|
|
|
|
|
(argv[1] && !get_oid_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 01:16:36 +00:00
|
|
|
/*
|
2013-01-15 05:47:49 +00: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 01:16:36 +00:00
|
|
|
* be a filename.
|
|
|
|
|
*/
|
2013-01-15 05:47:38 +00: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 01:16:36 +00:00
|
|
|
} else {
|
|
|
|
|
/* Otherwise we treat this as a filename */
|
2013-01-15 05:47:38 +00: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 01:16:36 +00:00
|
|
|
}
|
|
|
|
|
}
|
2013-01-15 05:47:37 +00:00
|
|
|
*rev_ret = rev;
|
2013-09-12 19:25:01 +00:00
|
|
|
|
|
|
|
|
if (read_cache() < 0)
|
|
|
|
|
die(_("index file corrupt"));
|
|
|
|
|
|
2013-07-14 08:35:50 +00:00
|
|
|
parse_pathspec(pathspec, 0,
|
|
|
|
|
PATHSPEC_PREFER_FULL |
|
|
|
|
|
(patch_mode ? PATHSPEC_PREFIX_ORIGIN : 0),
|
2013-07-14 08:35:47 +00:00
|
|
|
prefix, argv);
|
2013-01-15 05:47:37 +00:00
|
|
|
}
|
|
|
|
|
|
2016-09-05 20:08:11 +00:00
|
|
|
static int reset_refs(const char *rev, const struct object_id *oid)
|
2013-01-15 05:47:39 +00:00
|
|
|
{
|
|
|
|
|
int update_ref_status;
|
|
|
|
|
struct strbuf msg = STRBUF_INIT;
|
2016-09-05 20:08:11 +00:00
|
|
|
struct object_id *orig = NULL, oid_orig,
|
|
|
|
|
*old_orig = NULL, oid_old_orig;
|
2013-01-15 05:47:39 +00:00
|
|
|
|
2016-09-05 20:08:11 +00:00
|
|
|
if (!get_oid("ORIG_HEAD", &oid_old_orig))
|
|
|
|
|
old_orig = &oid_old_orig;
|
|
|
|
|
if (!get_oid("HEAD", &oid_orig)) {
|
|
|
|
|
orig = &oid_orig;
|
2013-01-15 05:47:39 +00:00
|
|
|
set_reflog_message(&msg, "updating ORIG_HEAD", NULL);
|
2017-10-15 22:06:51 +00:00
|
|
|
update_ref(msg.buf, "ORIG_HEAD", orig, old_orig, 0,
|
2014-04-07 13:47:56 +00:00
|
|
|
UPDATE_REFS_MSG_ON_ERR);
|
2013-01-15 05:47:39 +00:00
|
|
|
} else if (old_orig)
|
2017-10-15 22:06:50 +00:00
|
|
|
delete_ref(NULL, "ORIG_HEAD", old_orig, 0);
|
2013-01-15 05:47:39 +00:00
|
|
|
set_reflog_message(&msg, "updating HEAD", rev);
|
2017-10-15 22:06:51 +00:00
|
|
|
update_ref_status = update_ref(msg.buf, "HEAD", oid, orig, 0,
|
2014-04-07 13:47:56 +00:00
|
|
|
UPDATE_REFS_MSG_ON_ERR);
|
2013-01-15 05:47:39 +00:00
|
|
|
strbuf_release(&msg);
|
|
|
|
|
return update_ref_status;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-01 00:30:47 +00:00
|
|
|
static int git_reset_config(const char *var, const char *value, void *cb)
|
|
|
|
|
{
|
|
|
|
|
if (!strcmp(var, "submodule.recurse"))
|
|
|
|
|
return git_default_submodule_config(var, value, cb);
|
|
|
|
|
|
|
|
|
|
return git_default_config(var, value, cb);
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-15 05:47:37 +00:00
|
|
|
int cmd_reset(int argc, const char **argv, const char *prefix)
|
|
|
|
|
{
|
|
|
|
|
int reset_type = NONE, update_ref_status = 0, quiet = 0;
|
2019-11-19 16:48:53 +00:00
|
|
|
int patch_mode = 0, pathspec_file_nul = 0, unborn;
|
|
|
|
|
const char *rev, *pathspec_from_file = NULL;
|
2015-11-10 02:22:28 +00:00
|
|
|
struct object_id oid;
|
2013-07-14 08:35:47 +00:00
|
|
|
struct pathspec pathspec;
|
2014-02-04 02:20:09 +00:00
|
|
|
int intent_to_add = 0;
|
2013-01-15 05:47:37 +00: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),
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 08:36:28 +00:00
|
|
|
OPT_CALLBACK_F(0, "recurse-submodules", NULL,
|
2017-04-21 17:39:53 +00:00
|
|
|
"reset", "control recursive updating of submodules",
|
Use OPT_CALLBACK and OPT_CALLBACK_F
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.
Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:
#!/bin/sh
do_replacement () {
tr '\n' '\r' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
tr '\r' '\n'
}
for f in $(git ls-files \*.c)
do
do_replacement <"$f" >"$f.tmp"
mv "$f.tmp" "$f"
done
The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-28 08:36:28 +00:00
|
|
|
PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('p', "patch", &patch_mode, N_("select hunks interactively")),
|
2014-02-04 02:20:09 +00:00
|
|
|
OPT_BOOL('N', "intent-to-add", &intent_to_add,
|
|
|
|
|
N_("record only the fact that removed paths will be added later")),
|
2019-11-19 16:48:53 +00:00
|
|
|
OPT_PATHSPEC_FROM_FILE(&pathspec_from_file),
|
|
|
|
|
OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul),
|
2013-01-15 05:47:37 +00:00
|
|
|
OPT_END()
|
|
|
|
|
};
|
|
|
|
|
|
2017-06-01 00:30:47 +00:00
|
|
|
git_config(git_reset_config, NULL);
|
2018-10-23 19:04:22 +00:00
|
|
|
git_config_get_bool("reset.quiet", &quiet);
|
2013-01-15 05:47:37 +00:00
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, options, git_reset_usage,
|
|
|
|
|
PARSE_OPT_KEEP_DASHDASH);
|
2013-07-14 08:35:47 +00:00
|
|
|
parse_args(&pathspec, argv, prefix, patch_mode, &rev);
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2019-11-19 16:48:53 +00:00
|
|
|
if (pathspec_from_file) {
|
|
|
|
|
if (patch_mode)
|
|
|
|
|
die(_("--pathspec-from-file is incompatible with --patch"));
|
|
|
|
|
|
|
|
|
|
if (pathspec.nr)
|
|
|
|
|
die(_("--pathspec-from-file is incompatible with pathspec arguments"));
|
|
|
|
|
|
|
|
|
|
parse_pathspec_file(&pathspec, 0,
|
|
|
|
|
PATHSPEC_PREFER_FULL,
|
|
|
|
|
prefix, pathspec_from_file, pathspec_file_nul);
|
|
|
|
|
} else if (pathspec_file_nul) {
|
|
|
|
|
die(_("--pathspec-file-nul requires --pathspec-from-file"));
|
|
|
|
|
}
|
|
|
|
|
|
sha1_name: convert get_sha1* to get_oid*
Now that all the callers of get_sha1 directly or indirectly use struct
object_id, rename the functions starting with get_sha1 to start with
get_oid. Convert the internals in sha1_name.c to use struct object_id
as well, and eliminate explicit length checks where possible. Convert a
use of 40 in get_oid_basic to GIT_SHA1_HEXSZ.
Outside of sha1_name.c and cache.h, this transition was made with the
following semantic patch:
@@
expression E1, E2;
@@
- get_sha1(E1, E2.hash)
+ get_oid(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1(E1, E2->hash)
+ get_oid(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2.hash)
+ get_oid_committish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2->hash)
+ get_oid_committish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2.hash)
+ get_oid_treeish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2->hash)
+ get_oid_treeish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2.hash)
+ get_oid_commit(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2->hash)
+ get_oid_commit(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2.hash)
+ get_oid_tree(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2->hash)
+ get_oid_tree(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2.hash)
+ get_oid_blob(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2->hash)
+ get_oid_blob(E1, E2)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3.hash, E4)
+ get_oid_with_context(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3->hash, E4)
+ get_oid_with_context(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-07-13 23:49:28 +00:00
|
|
|
unborn = !strcmp(rev, "HEAD") && get_oid("HEAD", &oid);
|
2013-01-15 05:47:50 +00:00
|
|
|
if (unborn) {
|
|
|
|
|
/* reset on unborn branch: treat as reset to empty tree */
|
2018-05-02 00:26:02 +00:00
|
|
|
oidcpy(&oid, the_hash_algo->empty_tree);
|
2019-11-24 20:25:49 +00:00
|
|
|
} else if (!pathspec.nr && !patch_mode) {
|
2013-01-15 05:47:49 +00:00
|
|
|
struct commit *commit;
|
sha1_name: convert get_sha1* to get_oid*
Now that all the callers of get_sha1 directly or indirectly use struct
object_id, rename the functions starting with get_sha1 to start with
get_oid. Convert the internals in sha1_name.c to use struct object_id
as well, and eliminate explicit length checks where possible. Convert a
use of 40 in get_oid_basic to GIT_SHA1_HEXSZ.
Outside of sha1_name.c and cache.h, this transition was made with the
following semantic patch:
@@
expression E1, E2;
@@
- get_sha1(E1, E2.hash)
+ get_oid(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1(E1, E2->hash)
+ get_oid(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2.hash)
+ get_oid_committish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2->hash)
+ get_oid_committish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2.hash)
+ get_oid_treeish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2->hash)
+ get_oid_treeish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2.hash)
+ get_oid_commit(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2->hash)
+ get_oid_commit(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2.hash)
+ get_oid_tree(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2->hash)
+ get_oid_tree(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2.hash)
+ get_oid_blob(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2->hash)
+ get_oid_blob(E1, E2)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3.hash, E4)
+ get_oid_with_context(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3->hash, E4)
+ get_oid_with_context(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-07-13 23:49:28 +00:00
|
|
|
if (get_oid_committish(rev, &oid))
|
2013-01-15 05:47:49 +00:00
|
|
|
die(_("Failed to resolve '%s' as a valid revision."), rev);
|
2018-06-29 01:21:58 +00:00
|
|
|
commit = lookup_commit_reference(the_repository, &oid);
|
2013-01-15 05:47:49 +00:00
|
|
|
if (!commit)
|
|
|
|
|
die(_("Could not parse object '%s'."), rev);
|
2015-11-10 02:22:28 +00:00
|
|
|
oidcpy(&oid, &commit->object.oid);
|
2013-01-15 05:47:49 +00:00
|
|
|
} else {
|
|
|
|
|
struct tree *tree;
|
sha1_name: convert get_sha1* to get_oid*
Now that all the callers of get_sha1 directly or indirectly use struct
object_id, rename the functions starting with get_sha1 to start with
get_oid. Convert the internals in sha1_name.c to use struct object_id
as well, and eliminate explicit length checks where possible. Convert a
use of 40 in get_oid_basic to GIT_SHA1_HEXSZ.
Outside of sha1_name.c and cache.h, this transition was made with the
following semantic patch:
@@
expression E1, E2;
@@
- get_sha1(E1, E2.hash)
+ get_oid(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1(E1, E2->hash)
+ get_oid(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2.hash)
+ get_oid_committish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2->hash)
+ get_oid_committish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2.hash)
+ get_oid_treeish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2->hash)
+ get_oid_treeish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2.hash)
+ get_oid_commit(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2->hash)
+ get_oid_commit(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2.hash)
+ get_oid_tree(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2->hash)
+ get_oid_tree(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2.hash)
+ get_oid_blob(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2->hash)
+ get_oid_blob(E1, E2)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3.hash, E4)
+ get_oid_with_context(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3->hash, E4)
+ get_oid_with_context(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-07-13 23:49:28 +00:00
|
|
|
if (get_oid_treeish(rev, &oid))
|
2013-01-15 05:47:49 +00:00
|
|
|
die(_("Failed to resolve '%s' as a valid tree."), rev);
|
2017-05-06 22:10:37 +00:00
|
|
|
tree = parse_tree_indirect(&oid);
|
2013-01-15 05:47:49 +00:00
|
|
|
if (!tree)
|
|
|
|
|
die(_("Could not parse object '%s'."), rev);
|
2015-11-10 02:22:28 +00:00
|
|
|
oidcpy(&oid, &tree->object.oid);
|
2013-01-15 05:47:49 +00:00
|
|
|
}
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2009-08-15 11:48:31 +00:00
|
|
|
if (patch_mode) {
|
|
|
|
|
if (reset_type != NONE)
|
2011-02-22 23:42:06 +00:00
|
|
|
die(_("--patch is incompatible with --{hard,mixed,soft}"));
|
2019-02-22 22:25:09 +00:00
|
|
|
trace2_cmd_mode("patch-interactive");
|
2013-10-25 06:54:06 +00:00
|
|
|
return run_add_interactive(rev, "--patch=reset", &pathspec);
|
2009-08-15 11:48:31 +00:00
|
|
|
}
|
|
|
|
|
|
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. */
|
2013-07-14 08:35:47 +00:00
|
|
|
if (pathspec.nr) {
|
2007-09-11 03:19:34 +00:00
|
|
|
if (reset_type == MIXED)
|
2011-02-22 23:42:06 +00:00
|
|
|
warning(_("--mixed with paths is deprecated; use 'git reset -- <paths>' instead."));
|
2007-09-11 03:19:34 +00:00
|
|
|
else if (reset_type != NONE)
|
2011-02-22 23:42:07 +00:00
|
|
|
die(_("Cannot do %s reset with paths."),
|
|
|
|
|
_(reset_type_names[reset_type]));
|
2007-09-11 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
if (reset_type == NONE)
|
|
|
|
|
reset_type = MIXED; /* by default */
|
|
|
|
|
|
2019-02-22 22:25:09 +00:00
|
|
|
if (pathspec.nr)
|
|
|
|
|
trace2_cmd_mode("path");
|
|
|
|
|
else
|
|
|
|
|
trace2_cmd_mode(reset_type_names[reset_type]);
|
|
|
|
|
|
2014-02-16 02:28:03 +00:00
|
|
|
if (reset_type != SOFT && (reset_type != MIXED || get_git_work_tree()))
|
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())
|
2011-02-22 23:42:07 +00:00
|
|
|
die(_("%s reset is not allowed in a bare repository"),
|
|
|
|
|
_(reset_type_names[reset_type]));
|
2009-12-30 05:54:44 +00:00
|
|
|
|
2014-02-04 02:20:09 +00:00
|
|
|
if (intent_to_add && reset_type != MIXED)
|
|
|
|
|
die(_("-N can only be used with --mixed"));
|
|
|
|
|
|
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. */
|
2013-01-15 05:47:40 +00:00
|
|
|
if (reset_type == SOFT || reset_type == KEEP)
|
2010-01-19 04:26:01 +00:00
|
|
|
die_if_unmerged_cache(reset_type);
|
2013-01-15 05:47:40 +00:00
|
|
|
|
|
|
|
|
if (reset_type != SOFT) {
|
2017-09-05 12:15:21 +00:00
|
|
|
struct lock_file lock = LOCK_INIT;
|
|
|
|
|
hold_locked_index(&lock, LOCK_DIE_ON_ERROR);
|
2013-01-15 05:47:51 +00:00
|
|
|
if (reset_type == MIXED) {
|
2013-08-30 21:56:45 +00:00
|
|
|
int flags = quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN;
|
2016-09-05 20:08:11 +00:00
|
|
|
if (read_from_tree(&pathspec, &oid, intent_to_add))
|
2013-01-15 05:47:47 +00:00
|
|
|
return 1;
|
2019-02-15 17:59:21 +00:00
|
|
|
the_index.updated_skipworktree = 1;
|
2018-10-23 19:04:23 +00:00
|
|
|
if (!quiet && get_git_work_tree()) {
|
|
|
|
|
uint64_t t_begin, t_delta_in_ms;
|
|
|
|
|
|
|
|
|
|
t_begin = getnanotime();
|
2014-02-16 02:28:03 +00:00
|
|
|
refresh_index(&the_index, flags, NULL, NULL,
|
|
|
|
|
_("Unstaged changes after reset:"));
|
2018-10-23 19:04:23 +00:00
|
|
|
t_delta_in_ms = (getnanotime() - t_begin) / 1000000;
|
2021-08-23 10:44:00 +00:00
|
|
|
if (advice_enabled(ADVICE_RESET_QUIET_WARNING) && t_delta_in_ms > REFRESH_INDEX_DELAY_WARNING_IN_MS) {
|
2018-10-23 19:04:23 +00:00
|
|
|
printf(_("\nIt took %.2f seconds to enumerate unstaged changes after reset. You can\n"
|
|
|
|
|
"use '--quiet' to avoid this. Set the config setting reset.quiet to true\n"
|
|
|
|
|
"to make this the default.\n"), t_delta_in_ms / 1000.0);
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-01-15 05:47:47 +00:00
|
|
|
} else {
|
2020-03-16 18:05:07 +00:00
|
|
|
struct object_id dummy;
|
|
|
|
|
char *ref = NULL;
|
|
|
|
|
int err;
|
|
|
|
|
|
2020-09-01 22:28:09 +00:00
|
|
|
dwim_ref(rev, strlen(rev), &dummy, &ref, 0);
|
2020-03-16 18:05:07 +00:00
|
|
|
if (ref && !starts_with(ref, "refs/"))
|
2021-03-14 18:47:35 +00:00
|
|
|
FREE_AND_NULL(ref);
|
2020-03-16 18:05:07 +00:00
|
|
|
|
|
|
|
|
err = reset_index(ref, &oid, reset_type, quiet);
|
2013-01-15 05:47:47 +00:00
|
|
|
if (reset_type == KEEP && !err)
|
2020-03-16 18:05:07 +00:00
|
|
|
err = reset_index(ref, &oid, MIXED, quiet);
|
2013-01-15 05:47:47 +00:00
|
|
|
if (err)
|
|
|
|
|
die(_("Could not reset index file to revision '%s'."), rev);
|
2020-03-16 18:05:07 +00:00
|
|
|
free(ref);
|
2013-01-15 05:47:47 +00:00
|
|
|
}
|
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 05:47:46 +00:00
|
|
|
|
2017-09-05 12:15:21 +00:00
|
|
|
if (write_locked_index(&the_index, &lock, COMMIT_LOCK))
|
2013-01-15 05:47:42 +00:00
|
|
|
die(_("Could not write new index file."));
|
2007-09-11 03:19:34 +00:00
|
|
|
}
|
|
|
|
|
|
2013-07-14 08:35:47 +00:00
|
|
|
if (!pathspec.nr && !unborn) {
|
2013-01-15 05:47:47 +00:00
|
|
|
/* Any resets without paths update HEAD to the head being
|
|
|
|
|
* switched to, saving the previous head in ORIG_HEAD before. */
|
2016-09-05 20:08:11 +00:00
|
|
|
update_ref_status = reset_refs(rev, &oid);
|
2007-09-11 03:19:34 +00:00
|
|
|
|
2013-01-15 05:47:47 +00:00
|
|
|
if (reset_type == HARD && !update_ref_status && !quiet)
|
2018-06-29 01:21:58 +00:00
|
|
|
print_new_head_line(lookup_commit_reference(the_repository, &oid));
|
2013-01-15 05:47:47 +00:00
|
|
|
}
|
2013-07-14 08:35:47 +00:00
|
|
|
if (!pathspec.nr)
|
2019-03-29 10:38:59 +00:00
|
|
|
remove_branch_state(the_repository, 0);
|
2007-09-11 03:19:34 +00:00
|
|
|
|
|
|
|
|
return update_ref_status;
|
|
|
|
|
}
|