1
+/*
2
+ * "git reset" builtin command
3
+ *
4
+ * Copyright (c) 2007 Carlos Rica
5
+ *
6
+ * Based on git-reset.sh, which is
7
+ *
8
+ * Copyright (c) 2005, 2006 Linus Torvalds and Junio C Hamano
9
+ */
10
+#include "cache.h"
11
+#include "tag.h"
12
+#include "object.h"
13
+#include "commit.h"
14
+#include "run-command.h"
15
+#include "refs.h"
16
+#include "diff.h"
17
+#include "diffcore.h"
18
+#include "tree.h"
19
+
20
+static const char builtin_reset_usage[] =
21
+"git-reset [--mixed | --soft | --hard] [<commit-ish>] [ [--] <paths>...]";
22
+
23
+static char *args_to_str(const char **argv)
24
+{
25
+ char *buf = NULL;
26
+ unsigned long len, space = 0, nr = 0;
27
+
28
+ for (; *argv; argv++) {
29
+ len = strlen(*argv);
30
+ ALLOC_GROW(buf, nr + 1 + len, space);
31
+ if (nr)
32
+ buf[nr++] = ' ';
33
+ memcpy(buf + nr, *argv, len);
34
+ nr += len;
35
+ }
36
+ ALLOC_GROW(buf, nr + 1, space);
37
+ buf[nr] = '\0';
38
+
39
+ return buf;
40
+}
41
+
42
+static inline int is_merge(void)
43
+{
44
+ return !access(git_path("MERGE_HEAD"), F_OK);
45
+}
46
+
47
+static int unmerged_files(void)
48
+{
49
+ char b;
50
+ ssize_t len;
51
+ struct child_process cmd;
52
+ const char *argv_ls_files[] = {"ls-files", "--unmerged", NULL};
53
+
54
+ memset(&cmd, 0, sizeof(cmd));
55
+ cmd.argv = argv_ls_files;
56
+ cmd.git_cmd = 1;
57
+ cmd.out = -1;
58
+
59
+ if (start_command(&cmd))
60
+ die("Could not run sub-command: git ls-files");
61
+
62
+ len = xread(cmd.out, &b, 1);
63
+ if (len < 0)
64
+ die("Could not read output from git ls-files: %s",
65
+ strerror(errno));
66
+ finish_command(&cmd);
67
+
68
+ return len;
69
+}
70
+
71
+static int reset_index_file(const unsigned char *sha1, int is_hard_reset)
72
+{
73
+ int i = 0;
74
+ const char *args[6];
75
+
76
+ args[i++] = "read-tree";
77
+ args[i++] = "-v";
78
+ args[i++] = "--reset";
79
+ if (is_hard_reset)
80
+ args[i++] = "-u";
81
+ args[i++] = sha1_to_hex(sha1);
82
+ args[i] = NULL;
83
+
84
+ return run_command_v_opt(args, RUN_GIT_CMD);
85
+}
86
+
87
+static void print_new_head_line(struct commit *commit)
88
+{
89
+ const char *hex, *dots = "...", *body;
90
+
91
+ hex = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV);
92
+ if (!hex) {
93
+ hex = sha1_to_hex(commit->object.sha1);
94
+ dots = "";
95
+ }
96
+ printf("HEAD is now at %s%s", hex, dots);
97
+ body = strstr(commit->buffer, "\n\n");
98
+ if (body) {
99
+ const char *eol;
100
+ size_t len;
101
+ body += 2;
102
+ eol = strchr(body, '\n');
103
+ len = eol ? eol - body : strlen(body);
104
+ printf(" %.*s\n", (int) len, body);
105
+ }
106
+ else
107
+ printf("\n");
108
+}
109
+
110
+static int update_index_refresh(void)
111
+{
112
+ const char *argv_update_index[] = {"update-index", "--refresh", NULL};
113
+ return run_command_v_opt(argv_update_index, RUN_GIT_CMD);
114
+}
115
+
116
+static void update_index_from_diff(struct diff_queue_struct *q,
117
+ struct diff_options *opt, void *data)
118
+{
119
+ int i;
120
+
121
+ /* do_diff_cache() mangled the index */
122
+ discard_cache();
123
+ read_cache();
124
+
125
+ for (i = 0; i < q->nr; i++) {
126
+ struct diff_filespec *one = q->queue[i]->one;
127
+ if (one->mode) {
128
+ struct cache_entry *ce;
129
+ ce = make_cache_entry(one->mode, one->sha1, one->path,
130
+ 0, 0);
131
+ add_cache_entry(ce, ADD_CACHE_OK_TO_ADD |
132
+ ADD_CACHE_OK_TO_REPLACE);
133
+ } else
134
+ remove_file_from_cache(one->path);
135
+ }
136
+}
137
+
138
+static int read_from_tree(const char *prefix, const char **argv,
139
+ unsigned char *tree_sha1)
140
+{
141
+ struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
142
+ int index_fd;
143
+ struct diff_options opt;
144
+
145
+ memset(&opt, 0, sizeof(opt));
146
+ diff_tree_setup_paths(get_pathspec(prefix, (const char **)argv), &opt);
147
+ opt.output_format = DIFF_FORMAT_CALLBACK;
148
+ opt.format_callback = update_index_from_diff;
149
+
150
+ index_fd = hold_locked_index(lock, 1);
151
+ read_cache();
152
+ if (do_diff_cache(tree_sha1, &opt))
153
+ return 1;
154
+ diffcore_std(&opt);
155
+ diff_flush(&opt);
156
+ return write_cache(index_fd, active_cache, active_nr) ||
157
+ close(index_fd) ||
158
+ commit_locked_index(lock);
159
+}
160
+
161
+static void prepend_reflog_action(const char *action, char *buf, size_t size)
162
+{
163
+ const char *sep = ": ";
164
+ const char *rla = getenv("GIT_REFLOG_ACTION");
165
+ if (!rla)
166
+ rla = sep = "";
167
+ if (snprintf(buf, size, "%s%s%s", rla, sep, action) >= size)
168
+ warning("Reflog action message too long: %.*s...", 50, buf);
169
+}
170
+
171
+enum reset_type { MIXED, SOFT, HARD, NONE };
172
+static char *reset_type_names[] = { "mixed", "soft", "hard", NULL };
173
+
174
+int cmd_reset(int argc, const char **argv, const char *prefix)
175
+{
176
+ int i = 1, reset_type = NONE, update_ref_status = 0;
177
+ const char *rev = "HEAD";
178
+ unsigned char sha1[20], *orig = NULL, sha1_orig[20],
179
+ *old_orig = NULL, sha1_old_orig[20];
180
+ struct commit *commit;
181
+ char *reflog_action, msg[1024];
182
+
183
+ git_config(git_default_config);
184
+
185
+ reflog_action = args_to_str(argv);
186
+ setenv("GIT_REFLOG_ACTION", reflog_action, 0);
187
+
188
+ if (i < argc) {
189
+ if (!strcmp(argv[i], "--mixed")) {
190
+ reset_type = MIXED;
191
+ i++;
192
+ }
193
+ else if (!strcmp(argv[i], "--soft")) {
194
+ reset_type = SOFT;
195
+ i++;
196
+ }
197
+ else if (!strcmp(argv[i], "--hard")) {
198
+ reset_type = HARD;
199
+ i++;
200
+ }
201
+ }
202
+
203
+ if (i < argc && argv[i][0] != '-')
204
+ rev = argv[i++];
205
+
206
+ if (get_sha1(rev, sha1))
207
+ die("Failed to resolve '%s' as a valid ref.", rev);
208
+
209
+ commit = lookup_commit_reference(sha1);
210
+ if (!commit)
211
+ die("Could not parse object '%s'.", rev);
212
+ hashcpy(sha1, commit->object.sha1);
213
+
214
+ if (i < argc && !strcmp(argv[i], "--"))
215
+ i++;
216
+ else if (i < argc && argv[i][0] == '-')
217
+ usage(builtin_reset_usage);
218
+
219
+ /* git reset tree [--] paths... can be used to
220
+ * load chosen paths from the tree into the index without
221
+ * affecting the working tree nor HEAD. */
222
+ if (i < argc) {
223
+ if (reset_type == MIXED)
224
+ warning("--mixed option is deprecated with paths.");
225
+ else if (reset_type != NONE)
226
+ die("Cannot do %s reset with paths.",
227
+ reset_type_names[reset_type]);
228
+ if (read_from_tree(prefix, argv + i, sha1))
229
+ return 1;
230
+ return update_index_refresh() ? 1 : 0;
231
+ }
232
+ if (reset_type == NONE)
233
+ reset_type = MIXED; /* by default */
234
+
235
+ /* Soft reset does not touch the index file nor the working tree
236
+ * at all, but requires them in a good order. Other resets reset
237
+ * the index file to the tree object we are switching to. */
238
+ if (reset_type == SOFT) {
239
+ if (is_merge() || unmerged_files())
240
+ die("Cannot do a soft reset in the middle of a merge.");
241
+ }
242
+ else if (reset_index_file(sha1, (reset_type == HARD)))
243
+ die("Could not reset index file to revision '%s'.", rev);
244
+
245
+ /* Any resets update HEAD to the head being switched to,
246
+ * saving the previous head in ORIG_HEAD before. */
247
+ if (!get_sha1("ORIG_HEAD", sha1_old_orig))
248
+ old_orig = sha1_old_orig;
249
+ if (!get_sha1("HEAD", sha1_orig)) {
250
+ orig = sha1_orig;
251
+ prepend_reflog_action("updating ORIG_HEAD", msg, sizeof(msg));
252
+ update_ref(msg, "ORIG_HEAD", orig, old_orig, 0, MSG_ON_ERR);
253
+ }
254
+ else if (old_orig)
255
+ delete_ref("ORIG_HEAD", old_orig);
256
+ prepend_reflog_action("updating HEAD", msg, sizeof(msg));
257
+ update_ref_status = update_ref(msg, "HEAD", sha1, orig, 0, MSG_ON_ERR);
258
+
259
+ switch (reset_type) {
260
+ case HARD:
261
+ if (!update_ref_status)
262
+ print_new_head_line(commit);
263
+ break;
264
+ case SOFT: /* Nothing else to do. */
265
+ break;
266
+ case MIXED: /* Report what has not been updated. */
267
+ update_index_refresh();
268
+ break;
269
+ }
270
+
271
+ unlink(git_path("MERGE_HEAD"));
272
+ unlink(git_path("rr-cache/MERGE_RR"));
273
+ unlink(git_path("MERGE_MSG"));
274
+ unlink(git_path("SQUASH_MSG"));
275
+
276
+ free(reflog_action);
277
+
278
+ return update_ref_status;
279
+}