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_REPOSITORY_VARIABLE
14 #include "environment.h"
26 #include "object-name.h"
27 #include "parse-options.h"
29 #include "repository.h"
30 #include "unpack-trees.h"
31 #include "cache-tree.h"
33 #include "sparse-index.h"
34 #include "submodule.h"
38 #include "add-interactive.h"
40 #define REFRESH_INDEX_DELAY_WARNING_IN_MS (2 * 1000)
42 static const char * const git_reset_usage
[] = {
43 N_("git reset [--mixed | --soft | --hard | --merge | --keep] [-q] [<commit>]"),
44 N_("git reset [-q] [<tree-ish>] [--] <pathspec>..."),
45 N_("git reset [-q] [--pathspec-from-file [--pathspec-file-nul]] [<tree-ish>]"),
46 N_("git reset --patch [<tree-ish>] [--] [<pathspec>...]"),
50 enum reset_type
{ MIXED
, SOFT
, HARD
, MERGE
, KEEP
, NONE
};
51 static const char *reset_type_names
[] = {
52 N_("mixed"), N_("soft"), N_("hard"), N_("merge"), N_("keep"), NULL
55 static inline int is_merge(void)
57 return !access(git_path_merge_head(the_repository
), F_OK
);
60 static int reset_index(const char *ref
, const struct object_id
*oid
, int reset_type
, int quiet
)
63 struct tree_desc desc
[2];
65 struct unpack_trees_options opts
;
68 memset(&opts
, 0, sizeof(opts
));
70 opts
.src_index
= the_repository
->index
;
71 opts
.dst_index
= the_repository
->index
;
72 opts
.fn
= oneway_merge
;
74 init_checkout_metadata(&opts
.meta
, ref
, oid
, NULL
);
76 opts
.verbose_update
= 1;
81 opts
.preserve_ignored
= 0; /* FIXME: !overwrite_ignore */
85 opts
.reset
= UNPACK_RESET_OVERWRITE_UNTRACKED
;
86 opts
.skip_cache_tree_update
= 1;
89 opts
.reset
= UNPACK_RESET_PROTECT_UNTRACKED
;
90 opts
.skip_cache_tree_update
= 1;
91 /* but opts.update=0, so working tree not updated */
94 BUG("invalid reset_type passed to reset_index");
97 repo_read_index_unmerged(the_repository
);
99 if (reset_type
== KEEP
) {
100 struct object_id head_oid
;
101 if (repo_get_oid(the_repository
, "HEAD", &head_oid
))
102 return error(_("You do not have a valid HEAD."));
103 if (!fill_tree_descriptor(the_repository
, desc
+ nr
, &head_oid
))
104 return error(_("Failed to find tree of HEAD."));
106 opts
.fn
= twoway_merge
;
109 if (!fill_tree_descriptor(the_repository
, desc
+ nr
, oid
)) {
110 error(_("Failed to find tree of %s."), oid_to_hex(oid
));
115 if (unpack_trees(nr
, desc
, &opts
))
118 if (reset_type
== MIXED
|| reset_type
== HARD
) {
119 tree
= parse_tree_indirect(oid
);
121 error(_("unable to read tree (%s)"), oid_to_hex(oid
));
124 prime_cache_tree(the_repository
, the_repository
->index
, tree
);
130 for (i
= 0; i
< nr
; i
++)
131 free((void *)desc
[i
].buffer
);
135 static void print_new_head_line(struct commit
*commit
)
137 struct strbuf buf
= STRBUF_INIT
;
139 printf(_("HEAD is now at %s"),
140 repo_find_unique_abbrev(the_repository
, &commit
->object
.oid
, DEFAULT_ABBREV
));
142 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, &buf
);
144 printf(" %s", buf
.buf
);
146 strbuf_release(&buf
);
149 static void update_index_from_diff(struct diff_queue_struct
*q
,
150 struct diff_options
*opt UNUSED
,
154 int intent_to_add
= *(int *)data
;
156 for (i
= 0; i
< q
->nr
; i
++) {
158 struct diff_filespec
*one
= q
->queue
[i
]->one
;
159 int is_in_reset_tree
= one
->mode
&& !is_null_oid(&one
->oid
);
160 struct cache_entry
*ce
;
162 if (!is_in_reset_tree
&& !intent_to_add
) {
163 remove_file_from_index(the_repository
->index
, one
->path
);
167 ce
= make_cache_entry(the_repository
->index
, one
->mode
, &one
->oid
, one
->path
,
171 * If the file 1) corresponds to an existing index entry with
172 * skip-worktree set, or 2) does not exist in the index but is
173 * outside the sparse checkout definition, add a skip-worktree bit
174 * to the new index entry. Note that a sparse index will be expanded
175 * if this entry is outside the sparse cone - this is necessary
176 * to properly construct the reset sparse directory.
178 pos
= index_name_pos(the_repository
->index
, one
->path
, strlen(one
->path
));
179 if ((pos
>= 0 && ce_skip_worktree(the_repository
->index
->cache
[pos
])) ||
180 (pos
< 0 && !path_in_sparse_checkout(one
->path
, the_repository
->index
)))
181 ce
->ce_flags
|= CE_SKIP_WORKTREE
;
184 die(_("make_cache_entry failed for path '%s'"),
186 if (!is_in_reset_tree
) {
187 ce
->ce_flags
|= CE_INTENT_TO_ADD
;
188 set_object_name_for_intent_to_add_entry(ce
);
190 add_index_entry(the_repository
->index
, ce
,
191 ADD_CACHE_OK_TO_ADD
| ADD_CACHE_OK_TO_REPLACE
);
195 static int read_from_tree(const struct pathspec
*pathspec
,
196 struct object_id
*tree_oid
,
199 struct diff_options opt
;
201 memset(&opt
, 0, sizeof(opt
));
202 copy_pathspec(&opt
.pathspec
, pathspec
);
203 opt
.output_format
= DIFF_FORMAT_CALLBACK
;
204 opt
.format_callback
= update_index_from_diff
;
205 opt
.format_callback_data
= &intent_to_add
;
206 opt
.flags
.override_submodule_config
= 1;
207 opt
.flags
.recursive
= 1;
208 opt
.repo
= the_repository
;
209 opt
.change
= diff_change
;
210 opt
.add_remove
= diff_addremove
;
212 if (pathspec
->nr
&& pathspec_needs_expanded_index(the_repository
->index
, pathspec
))
213 ensure_full_index(the_repository
->index
);
215 if (do_diff_cache(tree_oid
, &opt
))
223 static void set_reflog_message(struct strbuf
*sb
, const char *action
,
226 const char *rla
= getenv("GIT_REFLOG_ACTION");
230 strbuf_addf(sb
, "%s: %s", rla
, action
);
232 strbuf_addf(sb
, "reset: moving to %s", rev
);
234 strbuf_addf(sb
, "reset: %s", action
);
237 static void die_if_unmerged_cache(int reset_type
)
239 if (is_merge() || unmerged_index(the_repository
->index
))
240 die(_("Cannot do a %s reset in the middle of a merge."),
241 _(reset_type_names
[reset_type
]));
245 static void parse_args(struct pathspec
*pathspec
,
246 const char **argv
, const char *prefix
,
248 const char **rev_ret
)
250 const char *rev
= "HEAD";
251 struct object_id unused
;
253 * Possible arguments are:
255 * git reset [-opts] [<rev>]
256 * git reset [-opts] <tree> [<paths>...]
257 * git reset [-opts] <tree> -- [<paths>...]
258 * git reset [-opts] -- [<paths>...]
259 * git reset [-opts] <paths>...
261 * At this point, argv points immediately after [-opts].
265 if (!strcmp(argv
[0], "--")) {
266 argv
++; /* reset to HEAD, possibly with paths */
267 } else if (argv
[1] && !strcmp(argv
[1], "--")) {
272 * Otherwise, argv[0] could be either <rev> or <paths> and
273 * has to be unambiguous. If there is a single argument, it
276 else if ((!argv
[1] && !repo_get_oid_committish(the_repository
, argv
[0], &unused
)) ||
277 (argv
[1] && !repo_get_oid_treeish(the_repository
, argv
[0], &unused
))) {
279 * Ok, argv[0] looks like a commit/tree; it should not
282 verify_non_filename(prefix
, argv
[0]);
285 /* Otherwise we treat this as a filename */
286 verify_filename(prefix
, argv
[0], 1);
290 /* treat '@' as a shortcut for 'HEAD' */
291 *rev_ret
= !strcmp("@", rev
) ? "HEAD" : rev
;
293 parse_pathspec(pathspec
, 0,
294 PATHSPEC_PREFER_FULL
|
295 (patch_mode
? PATHSPEC_PREFIX_ORIGIN
: 0),
299 static int reset_refs(const char *rev
, const struct object_id
*oid
)
301 int update_ref_status
;
302 struct strbuf msg
= STRBUF_INIT
;
303 struct object_id
*orig
= NULL
, oid_orig
,
304 *old_orig
= NULL
, oid_old_orig
;
306 if (!repo_get_oid(the_repository
, "ORIG_HEAD", &oid_old_orig
))
307 old_orig
= &oid_old_orig
;
308 if (!repo_get_oid(the_repository
, "HEAD", &oid_orig
)) {
310 set_reflog_message(&msg
, "updating ORIG_HEAD", NULL
);
311 refs_update_ref(get_main_ref_store(the_repository
), msg
.buf
,
312 "ORIG_HEAD", orig
, old_orig
, 0,
313 UPDATE_REFS_MSG_ON_ERR
);
315 refs_delete_ref(get_main_ref_store(the_repository
), NULL
,
316 "ORIG_HEAD", old_orig
, 0);
317 set_reflog_message(&msg
, "updating HEAD", rev
);
318 update_ref_status
= refs_update_ref(get_main_ref_store(the_repository
),
319 msg
.buf
, "HEAD", oid
, orig
, 0,
320 UPDATE_REFS_MSG_ON_ERR
);
321 strbuf_release(&msg
);
322 return update_ref_status
;
325 static int git_reset_config(const char *var
, const char *value
,
326 const struct config_context
*ctx
, void *cb
)
328 if (!strcmp(var
, "submodule.recurse"))
329 return git_default_submodule_config(var
, value
, cb
);
331 return git_default_config(var
, value
, ctx
, cb
);
334 int cmd_reset(int argc
,
337 struct repository
*repo UNUSED
)
339 int reset_type
= NONE
, update_ref_status
= 0, quiet
= 0;
341 int patch_mode
= 0, pathspec_file_nul
= 0, unborn
;
343 char *pathspec_from_file
= NULL
;
344 struct object_id oid
;
345 struct pathspec pathspec
;
346 int intent_to_add
= 0;
347 const struct option options
[] = {
348 OPT__QUIET(&quiet
, N_("be quiet, only report errors")),
349 OPT_BOOL(0, "no-refresh", &no_refresh
,
350 N_("skip refreshing the index after reset")),
351 OPT_SET_INT_F(0, "mixed", &reset_type
,
352 N_("reset HEAD and index"),
353 MIXED
, PARSE_OPT_NONEG
),
354 OPT_SET_INT_F(0, "soft", &reset_type
,
355 N_("reset only HEAD"),
356 SOFT
, PARSE_OPT_NONEG
),
357 OPT_SET_INT_F(0, "hard", &reset_type
,
358 N_("reset HEAD, index and working tree"),
359 HARD
, PARSE_OPT_NONEG
),
360 OPT_SET_INT_F(0, "merge", &reset_type
,
361 N_("reset HEAD, index and working tree"),
362 MERGE
, PARSE_OPT_NONEG
),
363 OPT_SET_INT_F(0, "keep", &reset_type
,
364 N_("reset HEAD but keep local changes"),
365 KEEP
, PARSE_OPT_NONEG
),
366 OPT_CALLBACK_F(0, "recurse-submodules", NULL
,
367 "reset", "control recursive updating of submodules",
369 option_parse_recurse_submodules_worktree_updater
),
370 OPT_BOOL('p', "patch", &patch_mode
, N_("select hunks interactively")),
371 OPT_BOOL('N', "intent-to-add", &intent_to_add
,
372 N_("record only the fact that removed paths will be added later")),
373 OPT_PATHSPEC_FROM_FILE(&pathspec_from_file
),
374 OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul
),
378 git_config(git_reset_config
, NULL
);
380 argc
= parse_options(argc
, argv
, prefix
, options
, git_reset_usage
,
381 PARSE_OPT_KEEP_DASHDASH
);
382 parse_args(&pathspec
, argv
, prefix
, patch_mode
, &rev
);
384 if (pathspec_from_file
) {
386 die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--patch");
389 die(_("'%s' and pathspec arguments cannot be used together"), "--pathspec-from-file");
391 parse_pathspec_file(&pathspec
, 0,
392 PATHSPEC_PREFER_FULL
,
393 prefix
, pathspec_from_file
, pathspec_file_nul
);
394 } else if (pathspec_file_nul
) {
395 die(_("the option '%s' requires '%s'"), "--pathspec-file-nul", "--pathspec-from-file");
398 unborn
= !strcmp(rev
, "HEAD") && repo_get_oid(the_repository
, "HEAD",
401 /* reset on unborn branch: treat as reset to empty tree */
402 oidcpy(&oid
, the_hash_algo
->empty_tree
);
403 } else if (!pathspec
.nr
&& !patch_mode
) {
404 struct commit
*commit
;
405 if (repo_get_oid_committish(the_repository
, rev
, &oid
))
406 die(_("Failed to resolve '%s' as a valid revision."), rev
);
407 commit
= lookup_commit_reference(the_repository
, &oid
);
409 die(_("Could not parse object '%s'."), rev
);
410 oidcpy(&oid
, &commit
->object
.oid
);
413 if (repo_get_oid_treeish(the_repository
, rev
, &oid
))
414 die(_("Failed to resolve '%s' as a valid tree."), rev
);
415 tree
= parse_tree_indirect(&oid
);
417 die(_("Could not parse object '%s'."), rev
);
418 oidcpy(&oid
, &tree
->object
.oid
);
422 if (reset_type
!= NONE
)
423 die(_("options '%s' and '%s' cannot be used together"), "--patch", "--{hard,mixed,soft}");
424 trace2_cmd_mode("patch-interactive");
425 update_ref_status
= !!run_add_p(the_repository
, ADD_P_RESET
, rev
,
430 /* git reset tree [--] paths... can be used to
431 * load chosen paths from the tree into the index without
432 * affecting the working tree nor HEAD. */
434 if (reset_type
== MIXED
)
435 warning(_("--mixed with paths is deprecated; use 'git reset -- <paths>' instead."));
436 else if (reset_type
!= NONE
)
437 die(_("Cannot do %s reset with paths."),
438 _(reset_type_names
[reset_type
]));
440 if (reset_type
== NONE
)
441 reset_type
= MIXED
; /* by default */
444 trace2_cmd_mode("path");
446 trace2_cmd_mode(reset_type_names
[reset_type
]);
448 if (reset_type
!= SOFT
&& (reset_type
!= MIXED
|| repo_get_work_tree(the_repository
)))
451 if (reset_type
== MIXED
&& is_bare_repository())
452 die(_("%s reset is not allowed in a bare repository"),
453 _(reset_type_names
[reset_type
]));
455 if (intent_to_add
&& reset_type
!= MIXED
)
456 die(_("the option '%s' requires '%s'"), "-N", "--mixed");
458 prepare_repo_settings(the_repository
);
459 the_repository
->settings
.command_requires_full_index
= 0;
461 if (repo_read_index(the_repository
) < 0)
462 die(_("index file corrupt"));
464 /* Soft reset does not touch the index file nor the working tree
465 * at all, but requires them in a good order. Other resets reset
466 * the index file to the tree object we are switching to. */
467 if (reset_type
== SOFT
|| reset_type
== KEEP
)
468 die_if_unmerged_cache(reset_type
);
470 if (reset_type
!= SOFT
) {
471 struct lock_file lock
= LOCK_INIT
;
472 repo_hold_locked_index(the_repository
, &lock
,
474 if (reset_type
== MIXED
) {
475 int flags
= quiet
? REFRESH_QUIET
: REFRESH_IN_PORCELAIN
;
476 if (read_from_tree(&pathspec
, &oid
, intent_to_add
)) {
477 update_ref_status
= 1;
480 the_repository
->index
->updated_skipworktree
= 1;
481 if (!no_refresh
&& repo_get_work_tree(the_repository
)) {
482 uint64_t t_begin
, t_delta_in_ms
;
484 t_begin
= getnanotime();
485 refresh_index(the_repository
->index
, flags
, NULL
, NULL
,
486 _("Unstaged changes after reset:"));
487 t_delta_in_ms
= (getnanotime() - t_begin
) / 1000000;
488 if (!quiet
&& advice_enabled(ADVICE_RESET_NO_REFRESH_WARNING
) && t_delta_in_ms
> REFRESH_INDEX_DELAY_WARNING_IN_MS
) {
489 advise(_("It took %.2f seconds to refresh the index after reset. You can use\n"
490 "'--no-refresh' to avoid this."), t_delta_in_ms
/ 1000.0);
494 struct object_id dummy
;
498 repo_dwim_ref(the_repository
, rev
, strlen(rev
),
500 if (ref
&& !starts_with(ref
, "refs/"))
503 err
= reset_index(ref
, &oid
, reset_type
, quiet
);
504 if (reset_type
== KEEP
&& !err
)
505 err
= reset_index(ref
, &oid
, MIXED
, quiet
);
507 die(_("Could not reset index file to revision '%s'."), rev
);
511 if (write_locked_index(the_repository
->index
, &lock
, COMMIT_LOCK
))
512 die(_("Could not write new index file."));
515 if (!pathspec
.nr
&& !unborn
) {
516 /* Any resets without paths update HEAD to the head being
517 * switched to, saving the previous head in ORIG_HEAD before. */
518 update_ref_status
= reset_refs(rev
, &oid
);
520 if (reset_type
== HARD
&& !update_ref_status
&& !quiet
)
521 print_new_head_line(lookup_commit_reference(the_repository
, &oid
));
524 remove_branch_state(the_repository
, 0);
526 discard_index(the_repository
->index
);
529 clear_pathspec(&pathspec
);
530 free(pathspec_from_file
);
531 return update_ref_status
;