2 * "git reset" builtin command
4 * Copyright (c) 2007 Carlos Rica
6 * Based on git-reset.sh, which is
8 * Copyright (c) 2005, 2006 Linus Torvalds and Junio C Hamano
10 #define USE_THE_INDEX_COMPATIBILITY_MACROS
17 #include "run-command.h"
23 #include "parse-options.h"
24 #include "unpack-trees.h"
25 #include "cache-tree.h"
26 #include "submodule.h"
27 #include "submodule-config.h"
30 #define REFRESH_INDEX_DELAY_WARNING_IN_MS (2 * 1000)
32 static const char * const git_reset_usage
[] = {
33 N_("git reset [--mixed | --soft | --hard | --merge | --keep] [-q] [<commit>]"),
34 N_("git reset [-q] [<tree-ish>] [--] <pathspec>..."),
35 N_("git reset [-q] [--pathspec-from-file [--pathspec-file-nul]] [<tree-ish>]"),
36 N_("git reset --patch [<tree-ish>] [--] [<pathspec>...]"),
40 enum reset_type
{ MIXED
, SOFT
, HARD
, MERGE
, KEEP
, NONE
};
41 static const char *reset_type_names
[] = {
42 N_("mixed"), N_("soft"), N_("hard"), N_("merge"), N_("keep"), NULL
45 static inline int is_merge(void)
47 return !access(git_path_merge_head(the_repository
), F_OK
);
50 static int reset_index(const char *ref
, const struct object_id
*oid
, int reset_type
, int quiet
)
53 struct tree_desc desc
[2];
55 struct unpack_trees_options opts
;
58 memset(&opts
, 0, sizeof(opts
));
60 opts
.src_index
= &the_index
;
61 opts
.dst_index
= &the_index
;
62 opts
.fn
= oneway_merge
;
64 init_checkout_metadata(&opts
.meta
, ref
, oid
, NULL
);
66 opts
.verbose_update
= 1;
71 opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
75 opts
.reset
= UNPACK_RESET_OVERWRITE_UNTRACKED
;
78 opts
.reset
= UNPACK_RESET_PROTECT_UNTRACKED
;
79 /* but opts.update=0, so working tree not updated */
82 BUG("invalid reset_type passed to reset_index");
85 read_cache_unmerged();
87 if (reset_type
== KEEP
) {
88 struct object_id head_oid
;
89 if (get_oid("HEAD", &head_oid
))
90 return error(_("You do not have a valid HEAD."));
91 if (!fill_tree_descriptor(the_repository
, desc
+ nr
, &head_oid
))
92 return error(_("Failed to find tree of HEAD."));
94 opts
.fn
= twoway_merge
;
97 if (!fill_tree_descriptor(the_repository
, desc
+ nr
, oid
)) {
98 error(_("Failed to find tree of %s."), oid_to_hex(oid
));
103 if (unpack_trees(nr
, desc
, &opts
))
106 if (reset_type
== MIXED
|| reset_type
== HARD
) {
107 tree
= parse_tree_indirect(oid
);
108 prime_cache_tree(the_repository
, the_repository
->index
, tree
);
114 for (i
= 0; i
< nr
; i
++)
115 free((void *)desc
[i
].buffer
);
119 static void print_new_head_line(struct commit
*commit
)
121 struct strbuf buf
= STRBUF_INIT
;
123 printf(_("HEAD is now at %s"),
124 find_unique_abbrev(&commit
->object
.oid
, DEFAULT_ABBREV
));
126 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, &buf
);
128 printf(" %s", buf
.buf
);
130 strbuf_release(&buf
);
133 static void update_index_from_diff(struct diff_queue_struct
*q
,
134 struct diff_options
*opt
, void *data
)
137 int intent_to_add
= *(int *)data
;
139 for (i
= 0; i
< q
->nr
; i
++) {
141 struct diff_filespec
*one
= q
->queue
[i
]->one
;
142 int is_in_reset_tree
= one
->mode
&& !is_null_oid(&one
->oid
);
143 struct cache_entry
*ce
;
145 if (!is_in_reset_tree
&& !intent_to_add
) {
146 remove_file_from_cache(one
->path
);
150 ce
= make_cache_entry(&the_index
, one
->mode
, &one
->oid
, one
->path
,
154 * If the file 1) corresponds to an existing index entry with
155 * skip-worktree set, or 2) does not exist in the index but is
156 * outside the sparse checkout definition, add a skip-worktree bit
157 * to the new index entry. Note that a sparse index will be expanded
158 * if this entry is outside the sparse cone - this is necessary
159 * to properly construct the reset sparse directory.
161 pos
= cache_name_pos(one
->path
, strlen(one
->path
));
162 if ((pos
>= 0 && ce_skip_worktree(active_cache
[pos
])) ||
163 (pos
< 0 && !path_in_sparse_checkout(one
->path
, &the_index
)))
164 ce
->ce_flags
|= CE_SKIP_WORKTREE
;
167 die(_("make_cache_entry failed for path '%s'"),
169 if (!is_in_reset_tree
) {
170 ce
->ce_flags
|= CE_INTENT_TO_ADD
;
171 set_object_name_for_intent_to_add_entry(ce
);
173 add_cache_entry(ce
, ADD_CACHE_OK_TO_ADD
| ADD_CACHE_OK_TO_REPLACE
);
177 static int pathspec_needs_expanded_index(const struct pathspec
*pathspec
)
181 char *skip_worktree_seen
= NULL
;
184 * When using a magic pathspec, assume for the sake of simplicity that
185 * the index needs to be expanded to match all matchable files.
190 for (i
= 0; i
< pathspec
->nr
; i
++) {
191 struct pathspec_item item
= pathspec
->items
[i
];
194 * If the pathspec item has a wildcard, the index should be expanded
195 * if the pathspec has the possibility of matching a subset of entries inside
196 * of a sparse directory (but not the entire directory).
198 * If the pathspec item is a literal path, the index only needs to be expanded
199 * if a) the pathspec isn't in the sparse checkout cone (to make sure we don't
200 * expand for in-cone files) and b) it doesn't match any sparse directories
201 * (since we can reset whole sparse directories without expanding them).
203 if (item
.nowildcard_len
< item
.len
) {
205 * Special case: if the pattern is a path inside the cone
206 * followed by only wildcards, the pattern cannot match
207 * partial sparse directories, so we know we don't need to
211 * - in-cone/foo***: doesn't need expanded index
212 * - not-in-cone/bar*: may need expanded index
213 * - **.c: may need expanded index
215 if (strspn(item
.original
+ item
.nowildcard_len
, "*") == item
.len
- item
.nowildcard_len
&&
216 path_in_cone_mode_sparse_checkout(item
.original
, &the_index
))
219 for (pos
= 0; pos
< active_nr
; pos
++) {
220 struct cache_entry
*ce
= active_cache
[pos
];
222 if (!S_ISSPARSEDIR(ce
->ce_mode
))
226 * If the pre-wildcard length is longer than the sparse
227 * directory name and the sparse directory is the first
228 * component of the pathspec, need to expand the index.
230 if (item
.nowildcard_len
> ce_namelen(ce
) &&
231 !strncmp(item
.original
, ce
->name
, ce_namelen(ce
))) {
237 * If the pre-wildcard length is shorter than the sparse
238 * directory and the pathspec does not match the whole
239 * directory, need to expand the index.
241 if (!strncmp(item
.original
, ce
->name
, item
.nowildcard_len
) &&
242 wildmatch(item
.original
, ce
->name
, 0)) {
247 } else if (!path_in_cone_mode_sparse_checkout(item
.original
, &the_index
) &&
248 !matches_skip_worktree(pathspec
, i
, &skip_worktree_seen
))
255 free(skip_worktree_seen
);
259 static int read_from_tree(const struct pathspec
*pathspec
,
260 struct object_id
*tree_oid
,
263 struct diff_options opt
;
265 memset(&opt
, 0, sizeof(opt
));
266 copy_pathspec(&opt
.pathspec
, pathspec
);
267 opt
.output_format
= DIFF_FORMAT_CALLBACK
;
268 opt
.format_callback
= update_index_from_diff
;
269 opt
.format_callback_data
= &intent_to_add
;
270 opt
.flags
.override_submodule_config
= 1;
271 opt
.flags
.recursive
= 1;
272 opt
.repo
= the_repository
;
273 opt
.change
= diff_change
;
274 opt
.add_remove
= diff_addremove
;
276 if (pathspec
->nr
&& the_index
.sparse_index
&& pathspec_needs_expanded_index(pathspec
))
277 ensure_full_index(&the_index
);
279 if (do_diff_cache(tree_oid
, &opt
))
287 static void set_reflog_message(struct strbuf
*sb
, const char *action
,
290 const char *rla
= getenv("GIT_REFLOG_ACTION");
294 strbuf_addf(sb
, "%s: %s", rla
, action
);
296 strbuf_addf(sb
, "reset: moving to %s", rev
);
298 strbuf_addf(sb
, "reset: %s", action
);
301 static void die_if_unmerged_cache(int reset_type
)
303 if (is_merge() || unmerged_cache())
304 die(_("Cannot do a %s reset in the middle of a merge."),
305 _(reset_type_names
[reset_type
]));
309 static void parse_args(struct pathspec
*pathspec
,
310 const char **argv
, const char *prefix
,
312 const char **rev_ret
)
314 const char *rev
= "HEAD";
315 struct object_id unused
;
317 * Possible arguments are:
319 * git reset [-opts] [<rev>]
320 * git reset [-opts] <tree> [<paths>...]
321 * git reset [-opts] <tree> -- [<paths>...]
322 * git reset [-opts] -- [<paths>...]
323 * git reset [-opts] <paths>...
325 * At this point, argv points immediately after [-opts].
329 if (!strcmp(argv
[0], "--")) {
330 argv
++; /* reset to HEAD, possibly with paths */
331 } else if (argv
[1] && !strcmp(argv
[1], "--")) {
336 * Otherwise, argv[0] could be either <rev> or <paths> and
337 * has to be unambiguous. If there is a single argument, it
340 else if ((!argv
[1] && !get_oid_committish(argv
[0], &unused
)) ||
341 (argv
[1] && !get_oid_treeish(argv
[0], &unused
))) {
343 * Ok, argv[0] looks like a commit/tree; it should not
346 verify_non_filename(prefix
, argv
[0]);
349 /* Otherwise we treat this as a filename */
350 verify_filename(prefix
, argv
[0], 1);
355 parse_pathspec(pathspec
, 0,
356 PATHSPEC_PREFER_FULL
|
357 (patch_mode
? PATHSPEC_PREFIX_ORIGIN
: 0),
361 static int reset_refs(const char *rev
, const struct object_id
*oid
)
363 int update_ref_status
;
364 struct strbuf msg
= STRBUF_INIT
;
365 struct object_id
*orig
= NULL
, oid_orig
,
366 *old_orig
= NULL
, oid_old_orig
;
368 if (!get_oid("ORIG_HEAD", &oid_old_orig
))
369 old_orig
= &oid_old_orig
;
370 if (!get_oid("HEAD", &oid_orig
)) {
372 set_reflog_message(&msg
, "updating ORIG_HEAD", NULL
);
373 update_ref(msg
.buf
, "ORIG_HEAD", orig
, old_orig
, 0,
374 UPDATE_REFS_MSG_ON_ERR
);
376 delete_ref(NULL
, "ORIG_HEAD", old_orig
, 0);
377 set_reflog_message(&msg
, "updating HEAD", rev
);
378 update_ref_status
= update_ref(msg
.buf
, "HEAD", oid
, orig
, 0,
379 UPDATE_REFS_MSG_ON_ERR
);
380 strbuf_release(&msg
);
381 return update_ref_status
;
384 static int git_reset_config(const char *var
, const char *value
, void *cb
)
386 if (!strcmp(var
, "submodule.recurse"))
387 return git_default_submodule_config(var
, value
, cb
);
389 return git_default_config(var
, value
, cb
);
392 int cmd_reset(int argc
, const char **argv
, const char *prefix
)
394 int reset_type
= NONE
, update_ref_status
= 0, quiet
= 0;
396 int patch_mode
= 0, pathspec_file_nul
= 0, unborn
;
397 const char *rev
, *pathspec_from_file
= NULL
;
398 struct object_id oid
;
399 struct pathspec pathspec
;
400 int intent_to_add
= 0;
401 const struct option options
[] = {
402 OPT__QUIET(&quiet
, N_("be quiet, only report errors")),
403 OPT_BOOL(0, "no-refresh", &no_refresh
,
404 N_("skip refreshing the index after reset")),
405 OPT_SET_INT(0, "mixed", &reset_type
,
406 N_("reset HEAD and index"), MIXED
),
407 OPT_SET_INT(0, "soft", &reset_type
, N_("reset only HEAD"), SOFT
),
408 OPT_SET_INT(0, "hard", &reset_type
,
409 N_("reset HEAD, index and working tree"), HARD
),
410 OPT_SET_INT(0, "merge", &reset_type
,
411 N_("reset HEAD, index and working tree"), MERGE
),
412 OPT_SET_INT(0, "keep", &reset_type
,
413 N_("reset HEAD but keep local changes"), KEEP
),
414 OPT_CALLBACK_F(0, "recurse-submodules", NULL
,
415 "reset", "control recursive updating of submodules",
416 PARSE_OPT_OPTARG
, option_parse_recurse_submodules_worktree_updater
),
417 OPT_BOOL('p', "patch", &patch_mode
, N_("select hunks interactively")),
418 OPT_BOOL('N', "intent-to-add", &intent_to_add
,
419 N_("record only the fact that removed paths will be added later")),
420 OPT_PATHSPEC_FROM_FILE(&pathspec_from_file
),
421 OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul
),
425 git_config(git_reset_config
, NULL
);
427 argc
= parse_options(argc
, argv
, prefix
, options
, git_reset_usage
,
428 PARSE_OPT_KEEP_DASHDASH
);
429 parse_args(&pathspec
, argv
, prefix
, patch_mode
, &rev
);
431 if (pathspec_from_file
) {
433 die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--patch");
436 die(_("'%s' and pathspec arguments cannot be used together"), "--pathspec-from-file");
438 parse_pathspec_file(&pathspec
, 0,
439 PATHSPEC_PREFER_FULL
,
440 prefix
, pathspec_from_file
, pathspec_file_nul
);
441 } else if (pathspec_file_nul
) {
442 die(_("the option '%s' requires '%s'"), "--pathspec-file-nul", "--pathspec-from-file");
445 unborn
= !strcmp(rev
, "HEAD") && get_oid("HEAD", &oid
);
447 /* reset on unborn branch: treat as reset to empty tree */
448 oidcpy(&oid
, the_hash_algo
->empty_tree
);
449 } else if (!pathspec
.nr
&& !patch_mode
) {
450 struct commit
*commit
;
451 if (get_oid_committish(rev
, &oid
))
452 die(_("Failed to resolve '%s' as a valid revision."), rev
);
453 commit
= lookup_commit_reference(the_repository
, &oid
);
455 die(_("Could not parse object '%s'."), rev
);
456 oidcpy(&oid
, &commit
->object
.oid
);
459 if (get_oid_treeish(rev
, &oid
))
460 die(_("Failed to resolve '%s' as a valid tree."), rev
);
461 tree
= parse_tree_indirect(&oid
);
463 die(_("Could not parse object '%s'."), rev
);
464 oidcpy(&oid
, &tree
->object
.oid
);
468 if (reset_type
!= NONE
)
469 die(_("options '%s' and '%s' cannot be used together"), "--patch", "--{hard,mixed,soft}");
470 trace2_cmd_mode("patch-interactive");
471 return run_add_interactive(rev
, "--patch=reset", &pathspec
);
474 /* git reset tree [--] paths... can be used to
475 * load chosen paths from the tree into the index without
476 * affecting the working tree nor HEAD. */
478 if (reset_type
== MIXED
)
479 warning(_("--mixed with paths is deprecated; use 'git reset -- <paths>' instead."));
480 else if (reset_type
!= NONE
)
481 die(_("Cannot do %s reset with paths."),
482 _(reset_type_names
[reset_type
]));
484 if (reset_type
== NONE
)
485 reset_type
= MIXED
; /* by default */
488 trace2_cmd_mode("path");
490 trace2_cmd_mode(reset_type_names
[reset_type
]);
492 if (reset_type
!= SOFT
&& (reset_type
!= MIXED
|| get_git_work_tree()))
495 if (reset_type
== MIXED
&& is_bare_repository())
496 die(_("%s reset is not allowed in a bare repository"),
497 _(reset_type_names
[reset_type
]));
499 if (intent_to_add
&& reset_type
!= MIXED
)
500 die(_("the option '%s' requires '%s'"), "-N", "--mixed");
502 prepare_repo_settings(the_repository
);
503 the_repository
->settings
.command_requires_full_index
= 0;
505 if (read_cache() < 0)
506 die(_("index file corrupt"));
508 /* Soft reset does not touch the index file nor the working tree
509 * at all, but requires them in a good order. Other resets reset
510 * the index file to the tree object we are switching to. */
511 if (reset_type
== SOFT
|| reset_type
== KEEP
)
512 die_if_unmerged_cache(reset_type
);
514 if (reset_type
!= SOFT
) {
515 struct lock_file lock
= LOCK_INIT
;
516 hold_locked_index(&lock
, LOCK_DIE_ON_ERROR
);
517 if (reset_type
== MIXED
) {
518 int flags
= quiet
? REFRESH_QUIET
: REFRESH_IN_PORCELAIN
;
519 if (read_from_tree(&pathspec
, &oid
, intent_to_add
))
521 the_index
.updated_skipworktree
= 1;
522 if (!no_refresh
&& get_git_work_tree()) {
523 uint64_t t_begin
, t_delta_in_ms
;
525 t_begin
= getnanotime();
526 refresh_index(&the_index
, flags
, NULL
, NULL
,
527 _("Unstaged changes after reset:"));
528 t_delta_in_ms
= (getnanotime() - t_begin
) / 1000000;
529 if (!quiet
&& advice_enabled(ADVICE_RESET_NO_REFRESH_WARNING
) && t_delta_in_ms
> REFRESH_INDEX_DELAY_WARNING_IN_MS
) {
530 advise(_("It took %.2f seconds to refresh the index after reset. You can use\n"
531 "'--no-refresh' to avoid this."), t_delta_in_ms
/ 1000.0);
535 struct object_id dummy
;
539 dwim_ref(rev
, strlen(rev
), &dummy
, &ref
, 0);
540 if (ref
&& !starts_with(ref
, "refs/"))
543 err
= reset_index(ref
, &oid
, reset_type
, quiet
);
544 if (reset_type
== KEEP
&& !err
)
545 err
= reset_index(ref
, &oid
, MIXED
, quiet
);
547 die(_("Could not reset index file to revision '%s'."), rev
);
551 if (write_locked_index(&the_index
, &lock
, COMMIT_LOCK
))
552 die(_("Could not write new index file."));
555 if (!pathspec
.nr
&& !unborn
) {
556 /* Any resets without paths update HEAD to the head being
557 * switched to, saving the previous head in ORIG_HEAD before. */
558 update_ref_status
= reset_refs(rev
, &oid
);
560 if (reset_type
== HARD
&& !update_ref_status
&& !quiet
)
561 print_new_head_line(lookup_commit_reference(the_repository
, &oid
));
564 remove_branch_state(the_repository
, 0);
566 return update_ref_status
;