Elijah Newren | bc5c5ec | 2023-05-16 06:33:57 +0000 | [diff] [blame] | 1 | #include "git-compat-util.h" |
Elijah Newren | 6c6ddf9 | 2023-04-11 03:00:39 +0000 | [diff] [blame] | 2 | #include "advice.h" |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 3 | #include "wt-status.h" |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 4 | #include "object.h" |
| 5 | #include "dir.h" |
| 6 | #include "commit.h" |
| 7 | #include "diff.h" |
Elijah Newren | 7ee24e1 | 2023-03-21 06:25:57 +0000 | [diff] [blame] | 8 | #include "environment.h" |
Elijah Newren | f394e09 | 2023-03-21 06:25:54 +0000 | [diff] [blame] | 9 | #include "gettext.h" |
Elijah Newren | df6e874 | 2023-05-16 06:34:00 +0000 | [diff] [blame] | 10 | #include "hash.h" |
Elijah Newren | 41771fa | 2023-02-24 00:09:27 +0000 | [diff] [blame] | 11 | #include "hex.h" |
Elijah Newren | dabab1d | 2023-04-11 00:41:49 -0700 | [diff] [blame] | 12 | #include "object-name.h" |
Elijah Newren | c339932 | 2023-05-16 06:33:59 +0000 | [diff] [blame] | 13 | #include "path.h" |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 14 | #include "revision.h" |
| 15 | #include "diffcore.h" |
Dmitry Potapov | a734d0b | 2008-03-07 05:30:58 +0300 | [diff] [blame] | 16 | #include "quote.h" |
Ping Yin | ac8d5af | 2008-04-12 23:05:32 +0800 | [diff] [blame] | 17 | #include "run-command.h" |
Jeff King | dbbcd44 | 2020-07-28 16:23:39 -0400 | [diff] [blame] | 18 | #include "strvec.h" |
Junio C Hamano | b6975ab | 2008-07-02 00:52:16 -0700 | [diff] [blame] | 19 | #include "remote.h" |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 20 | #include "refs.h" |
Jens Lehmann | 46a958b | 2010-06-25 16:56:47 +0200 | [diff] [blame] | 21 | #include "submodule.h" |
Nguyễn Thái Ngọc Duy | 323d053 | 2012-04-13 17:54:39 +0700 | [diff] [blame] | 22 | #include "column.h" |
Elijah Newren | 08c46a4 | 2023-05-16 06:33:56 +0000 | [diff] [blame] | 23 | #include "read-cache.h" |
Elijah Newren | e38da48 | 2023-03-21 06:26:05 +0000 | [diff] [blame] | 24 | #include "setup.h" |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 25 | #include "strbuf.h" |
Elijah Newren | 74ea5c9 | 2023-04-11 03:00:38 +0000 | [diff] [blame] | 26 | #include "trace.h" |
| 27 | #include "trace2.h" |
Elijah Newren | d4a4f92 | 2023-04-22 20:17:26 +0000 | [diff] [blame] | 28 | #include "tree.h" |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 29 | #include "utf8.h" |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 30 | #include "worktree.h" |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 31 | #include "lockfile.h" |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 32 | #include "sequencer.h" |
Rudy Rigot | ecbc23e | 2022-11-30 00:52:16 +0000 | [diff] [blame] | 33 | #include "fsmonitor-settings.h" |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 34 | |
Jeff Hostetler | 0a53561 | 2019-06-18 13:21:27 -0700 | [diff] [blame] | 35 | #define AB_DELAY_WARNING_IN_MS (2 * 1000) |
Rudy Rigot | ecbc23e | 2022-11-30 00:52:16 +0000 | [diff] [blame] | 36 | #define UF_DELAY_WARNING_IN_MS (2 * 1000) |
Jeff Hostetler | 0a53561 | 2019-06-18 13:21:27 -0700 | [diff] [blame] | 37 | |
Nguyễn Thái Ngọc Duy | 983dc69 | 2014-02-17 19:15:30 +0700 | [diff] [blame] | 38 | static const char cut_line[] = |
Jens Lehmann | 1a72cfd | 2013-12-05 20:44:14 +0100 | [diff] [blame] | 39 | "------------------------ >8 ------------------------\n"; |
| 40 | |
Junio C Hamano | 23900a9 | 2009-08-09 23:08:40 -0700 | [diff] [blame] | 41 | static char default_wt_status_colors[][COLOR_MAXLEN] = { |
Arjen Laarhoven | dc6ebd4 | 2009-02-13 22:53:40 +0100 | [diff] [blame] | 42 | GIT_COLOR_NORMAL, /* WT_STATUS_HEADER */ |
| 43 | GIT_COLOR_GREEN, /* WT_STATUS_UPDATED */ |
| 44 | GIT_COLOR_RED, /* WT_STATUS_CHANGED */ |
| 45 | GIT_COLOR_RED, /* WT_STATUS_UNTRACKED */ |
| 46 | GIT_COLOR_RED, /* WT_STATUS_NOBRANCH */ |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 47 | GIT_COLOR_RED, /* WT_STATUS_UNMERGED */ |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 48 | GIT_COLOR_GREEN, /* WT_STATUS_LOCAL_BRANCH */ |
| 49 | GIT_COLOR_RED, /* WT_STATUS_REMOTE_BRANCH */ |
Jeff King | 148135f | 2010-12-09 12:27:08 -0500 | [diff] [blame] | 50 | GIT_COLOR_NIL, /* WT_STATUS_ONBRANCH */ |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 51 | }; |
Junio C Hamano | 4d22965 | 2007-01-11 15:34:41 -0800 | [diff] [blame] | 52 | |
Junio C Hamano | d249b09 | 2009-08-09 21:59:30 -0700 | [diff] [blame] | 53 | static const char *color(int slot, struct wt_status *s) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 54 | { |
Jeff King | daa0c3d | 2011-08-17 22:04:23 -0700 | [diff] [blame] | 55 | const char *c = ""; |
| 56 | if (want_color(s->use_color)) |
| 57 | c = s->color_palette[slot]; |
Jeff King | 148135f | 2010-12-09 12:27:08 -0500 | [diff] [blame] | 58 | if (slot == WT_STATUS_ONBRANCH && color_is_nil(c)) |
| 59 | c = s->color_palette[WT_STATUS_HEADER]; |
| 60 | return c; |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 61 | } |
| 62 | |
Jonathan Nieder | becbdae | 2011-02-25 23:09:41 -0600 | [diff] [blame] | 63 | static void status_vprintf(struct wt_status *s, int at_bol, const char *color, |
| 64 | const char *fmt, va_list ap, const char *trail) |
| 65 | { |
| 66 | struct strbuf sb = STRBUF_INIT; |
| 67 | struct strbuf linebuf = STRBUF_INIT; |
| 68 | const char *line, *eol; |
| 69 | |
| 70 | strbuf_vaddf(&sb, fmt, ap); |
| 71 | if (!sb.len) { |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 72 | if (s->display_comment_prefix) { |
| 73 | strbuf_addch(&sb, comment_line_char); |
| 74 | if (!trail) |
| 75 | strbuf_addch(&sb, ' '); |
| 76 | } |
Jonathan Nieder | becbdae | 2011-02-25 23:09:41 -0600 | [diff] [blame] | 77 | color_print_strbuf(s->fp, color, &sb); |
| 78 | if (trail) |
| 79 | fprintf(s->fp, "%s", trail); |
| 80 | strbuf_release(&sb); |
| 81 | return; |
| 82 | } |
| 83 | for (line = sb.buf; *line; line = eol + 1) { |
| 84 | eol = strchr(line, '\n'); |
| 85 | |
| 86 | strbuf_reset(&linebuf); |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 87 | if (at_bol && s->display_comment_prefix) { |
Junio C Hamano | eff80a9 | 2013-01-16 20:18:48 +0100 | [diff] [blame] | 88 | strbuf_addch(&linebuf, comment_line_char); |
Jonathan Nieder | becbdae | 2011-02-25 23:09:41 -0600 | [diff] [blame] | 89 | if (*line != '\n' && *line != '\t') |
| 90 | strbuf_addch(&linebuf, ' '); |
| 91 | } |
| 92 | if (eol) |
| 93 | strbuf_add(&linebuf, line, eol - line); |
| 94 | else |
| 95 | strbuf_addstr(&linebuf, line); |
| 96 | color_print_strbuf(s->fp, color, &linebuf); |
| 97 | if (eol) |
| 98 | fprintf(s->fp, "\n"); |
| 99 | else |
| 100 | break; |
| 101 | at_bol = 1; |
| 102 | } |
| 103 | if (trail) |
| 104 | fprintf(s->fp, "%s", trail); |
| 105 | strbuf_release(&linebuf); |
| 106 | strbuf_release(&sb); |
| 107 | } |
| 108 | |
| 109 | void status_printf_ln(struct wt_status *s, const char *color, |
| 110 | const char *fmt, ...) |
| 111 | { |
| 112 | va_list ap; |
| 113 | |
| 114 | va_start(ap, fmt); |
| 115 | status_vprintf(s, 1, color, fmt, ap, "\n"); |
| 116 | va_end(ap); |
| 117 | } |
| 118 | |
| 119 | void status_printf(struct wt_status *s, const char *color, |
| 120 | const char *fmt, ...) |
| 121 | { |
| 122 | va_list ap; |
| 123 | |
| 124 | va_start(ap, fmt); |
| 125 | status_vprintf(s, 1, color, fmt, ap, NULL); |
| 126 | va_end(ap); |
| 127 | } |
| 128 | |
Junio C Hamano | 1e24845 | 2012-09-15 22:46:26 -0700 | [diff] [blame] | 129 | static void status_printf_more(struct wt_status *s, const char *color, |
| 130 | const char *fmt, ...) |
Jonathan Nieder | becbdae | 2011-02-25 23:09:41 -0600 | [diff] [blame] | 131 | { |
| 132 | va_list ap; |
| 133 | |
| 134 | va_start(ap, fmt); |
| 135 | status_vprintf(s, 0, color, fmt, ap, NULL); |
| 136 | va_end(ap); |
| 137 | } |
| 138 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 139 | void wt_status_prepare(struct repository *r, struct wt_status *s) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 140 | { |
Junio C Hamano | cc46a74 | 2007-02-09 16:22:42 -0800 | [diff] [blame] | 141 | memset(s, 0, sizeof(*s)); |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 142 | s->repo = r; |
Junio C Hamano | 23900a9 | 2009-08-09 23:08:40 -0700 | [diff] [blame] | 143 | memcpy(s->color_palette, default_wt_status_colors, |
| 144 | sizeof(default_wt_status_colors)); |
Junio C Hamano | d249b09 | 2009-08-09 21:59:30 -0700 | [diff] [blame] | 145 | s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES; |
| 146 | s->use_color = -1; |
| 147 | s->relative_paths = 1; |
René Scharfe | efbd4fd | 2017-10-01 09:29:03 +0200 | [diff] [blame] | 148 | s->branch = resolve_refdup("HEAD", 0, NULL, NULL); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 149 | s->reference = "HEAD"; |
Kristian Høgsberg | f26a001 | 2007-09-17 20:06:42 -0400 | [diff] [blame] | 150 | s->fp = stdout; |
Kristian Høgsberg | 0f729f2 | 2007-09-17 20:06:43 -0400 | [diff] [blame] | 151 | s->index_file = get_index_file(); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 152 | s->change.strdup_strings = 1; |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 153 | s->untracked.strdup_strings = 1; |
Junio C Hamano | 6cb3f6b | 2010-04-10 00:11:53 -0700 | [diff] [blame] | 154 | s->ignored.strdup_strings = 1; |
Junio C Hamano | 84b4202 | 2013-06-24 11:41:40 -0700 | [diff] [blame] | 155 | s->show_branch = -1; /* unspecified */ |
Liam Beguin | c1b5d01 | 2017-06-17 18:30:51 -0400 | [diff] [blame] | 156 | s->show_stash = 0; |
Jeff Hostetler | fd9b544 | 2018-01-09 18:50:16 +0000 | [diff] [blame] | 157 | s->ahead_behind_flags = AHEAD_BEHIND_UNSPECIFIED; |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 158 | s->display_comment_prefix = 0; |
Ben Peart | e8b2dc2 | 2018-05-11 15:38:58 +0000 | [diff] [blame] | 159 | s->detect_rename = -1; |
| 160 | s->rename_score = -1; |
| 161 | s->rename_limit = -1; |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 162 | } |
| 163 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 164 | static void wt_longstatus_print_unmerged_header(struct wt_status *s) |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 165 | { |
Lucien Kong | 96b0ec1 | 2012-06-05 22:21:26 +0200 | [diff] [blame] | 166 | int i; |
| 167 | int del_mod_conflict = 0; |
| 168 | int both_deleted = 0; |
| 169 | int not_deleted = 0; |
Junio C Hamano | d249b09 | 2009-08-09 21:59:30 -0700 | [diff] [blame] | 170 | const char *c = color(WT_STATUS_HEADER, s); |
Junio C Hamano | 3c58845 | 2009-12-11 23:53:41 -0800 | [diff] [blame] | 171 | |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 172 | status_printf_ln(s, c, _("Unmerged paths:")); |
Lucien Kong | 96b0ec1 | 2012-06-05 22:21:26 +0200 | [diff] [blame] | 173 | |
| 174 | for (i = 0; i < s->change.nr; i++) { |
| 175 | struct string_list_item *it = &(s->change.items[i]); |
| 176 | struct wt_status_change_data *d = it->util; |
| 177 | |
| 178 | switch (d->stagemask) { |
| 179 | case 0: |
| 180 | break; |
| 181 | case 1: |
| 182 | both_deleted = 1; |
| 183 | break; |
| 184 | case 3: |
| 185 | case 5: |
| 186 | del_mod_conflict = 1; |
| 187 | break; |
| 188 | default: |
| 189 | not_deleted = 1; |
| 190 | break; |
| 191 | } |
| 192 | } |
| 193 | |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 194 | if (!s->hints) |
Jeff King | edf563f | 2009-09-09 07:43:03 -0400 | [diff] [blame] | 195 | return; |
Jay Soffian | 37f7a85 | 2011-02-19 23:12:29 -0500 | [diff] [blame] | 196 | if (s->whence != FROM_COMMIT) |
Junio C Hamano | 3c58845 | 2009-12-11 23:53:41 -0800 | [diff] [blame] | 197 | ; |
Nguyễn Thái Ngọc Duy | 80f537f | 2019-04-25 16:45:58 +0700 | [diff] [blame] | 198 | else if (!s->is_initial) { |
| 199 | if (!strcmp(s->reference, "HEAD")) |
| 200 | status_printf_ln(s, c, |
| 201 | _(" (use \"git restore --staged <file>...\" to unstage)")); |
| 202 | else |
| 203 | status_printf_ln(s, c, |
| 204 | _(" (use \"git restore --source=%s --staged <file>...\" to unstage)"), |
| 205 | s->reference); |
| 206 | } else |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 207 | status_printf_ln(s, c, _(" (use \"git rm --cached <file>...\" to unstage)")); |
Lucien Kong | 96b0ec1 | 2012-06-05 22:21:26 +0200 | [diff] [blame] | 208 | |
| 209 | if (!both_deleted) { |
| 210 | if (!del_mod_conflict) |
| 211 | status_printf_ln(s, c, _(" (use \"git add <file>...\" to mark resolution)")); |
| 212 | else |
| 213 | status_printf_ln(s, c, _(" (use \"git add/rm <file>...\" as appropriate to mark resolution)")); |
| 214 | } else if (!del_mod_conflict && !not_deleted) { |
| 215 | status_printf_ln(s, c, _(" (use \"git rm <file>...\" to mark resolution)")); |
| 216 | } else { |
| 217 | status_printf_ln(s, c, _(" (use \"git add/rm <file>...\" as appropriate to mark resolution)")); |
| 218 | } |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 219 | } |
| 220 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 221 | static void wt_longstatus_print_cached_header(struct wt_status *s) |
Jürgen Rühle | 3c1eb9c | 2007-01-02 20:26:21 +0100 | [diff] [blame] | 222 | { |
Junio C Hamano | d249b09 | 2009-08-09 21:59:30 -0700 | [diff] [blame] | 223 | const char *c = color(WT_STATUS_HEADER, s); |
Junio C Hamano | 3c58845 | 2009-12-11 23:53:41 -0800 | [diff] [blame] | 224 | |
Ævar Arnfjörð Bjarmason | 919a4ce | 2011-02-22 23:42:16 +0000 | [diff] [blame] | 225 | status_printf_ln(s, c, _("Changes to be committed:")); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 226 | if (!s->hints) |
Jeff King | edf563f | 2009-09-09 07:43:03 -0400 | [diff] [blame] | 227 | return; |
Jay Soffian | 37f7a85 | 2011-02-19 23:12:29 -0500 | [diff] [blame] | 228 | if (s->whence != FROM_COMMIT) |
Junio C Hamano | 3c58845 | 2009-12-11 23:53:41 -0800 | [diff] [blame] | 229 | ; /* NEEDSWORK: use "git reset --unresolve"??? */ |
Nguyễn Thái Ngọc Duy | 80f537f | 2019-04-25 16:45:58 +0700 | [diff] [blame] | 230 | else if (!s->is_initial) { |
| 231 | if (!strcmp(s->reference, "HEAD")) |
| 232 | status_printf_ln(s, c |
| 233 | , _(" (use \"git restore --staged <file>...\" to unstage)")); |
| 234 | else |
| 235 | status_printf_ln(s, c, |
| 236 | _(" (use \"git restore --source=%s --staged <file>...\" to unstage)"), |
| 237 | s->reference); |
| 238 | } else |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 239 | status_printf_ln(s, c, _(" (use \"git rm --cached <file>...\" to unstage)")); |
Jürgen Rühle | 3c1eb9c | 2007-01-02 20:26:21 +0100 | [diff] [blame] | 240 | } |
| 241 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 242 | static void wt_longstatus_print_dirty_header(struct wt_status *s, |
| 243 | int has_deleted, |
| 244 | int has_dirty_submodules) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 245 | { |
Junio C Hamano | d249b09 | 2009-08-09 21:59:30 -0700 | [diff] [blame] | 246 | const char *c = color(WT_STATUS_HEADER, s); |
Junio C Hamano | 3c58845 | 2009-12-11 23:53:41 -0800 | [diff] [blame] | 247 | |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 248 | status_printf_ln(s, c, _("Changes not staged for commit:")); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 249 | if (!s->hints) |
Jeff King | edf563f | 2009-09-09 07:43:03 -0400 | [diff] [blame] | 250 | return; |
Anders Melchiorsen | bb914b1 | 2008-09-08 00:05:02 +0200 | [diff] [blame] | 251 | if (!has_deleted) |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 252 | status_printf_ln(s, c, _(" (use \"git add <file>...\" to update what will be committed)")); |
Anders Melchiorsen | bb914b1 | 2008-09-08 00:05:02 +0200 | [diff] [blame] | 253 | else |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 254 | status_printf_ln(s, c, _(" (use \"git add/rm <file>...\" to update what will be committed)")); |
Nguyễn Thái Ngọc Duy | 80f537f | 2019-04-25 16:45:58 +0700 | [diff] [blame] | 255 | status_printf_ln(s, c, _(" (use \"git restore <file>...\" to discard changes in working directory)")); |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 256 | if (has_dirty_submodules) |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 257 | status_printf_ln(s, c, _(" (commit or discard the untracked or modified content in submodules)")); |
Anders Melchiorsen | bb914b1 | 2008-09-08 00:05:02 +0200 | [diff] [blame] | 258 | } |
| 259 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 260 | static void wt_longstatus_print_other_header(struct wt_status *s, |
| 261 | const char *what, |
| 262 | const char *how) |
Anders Melchiorsen | bb914b1 | 2008-09-08 00:05:02 +0200 | [diff] [blame] | 263 | { |
Junio C Hamano | d249b09 | 2009-08-09 21:59:30 -0700 | [diff] [blame] | 264 | const char *c = color(WT_STATUS_HEADER, s); |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 265 | status_printf_ln(s, c, "%s:", what); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 266 | if (!s->hints) |
Jeff King | edf563f | 2009-09-09 07:43:03 -0400 | [diff] [blame] | 267 | return; |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 268 | status_printf_ln(s, c, _(" (use \"git %s <file>...\" to include in what will be committed)"), how); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 269 | } |
| 270 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 271 | static void wt_longstatus_print_trailer(struct wt_status *s) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 272 | { |
Felipe Contreras | 7d7d680 | 2014-05-04 01:12:55 -0500 | [diff] [blame] | 273 | status_printf_ln(s, color(WT_STATUS_HEADER, s), "%s", ""); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 274 | } |
| 275 | |
Jonathan Nieder | 8f17f5b | 2013-12-19 11:43:19 -0800 | [diff] [blame] | 276 | static const char *wt_status_unmerged_status_string(int stagemask) |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 277 | { |
Jonathan Nieder | 8f17f5b | 2013-12-19 11:43:19 -0800 | [diff] [blame] | 278 | switch (stagemask) { |
| 279 | case 1: |
| 280 | return _("both deleted:"); |
| 281 | case 2: |
| 282 | return _("added by us:"); |
| 283 | case 3: |
| 284 | return _("deleted by them:"); |
| 285 | case 4: |
| 286 | return _("added by them:"); |
| 287 | case 5: |
| 288 | return _("deleted by us:"); |
| 289 | case 6: |
| 290 | return _("both added:"); |
| 291 | case 7: |
| 292 | return _("both modified:"); |
| 293 | default: |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 294 | BUG("unhandled unmerged status %x", stagemask); |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 295 | } |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 296 | } |
| 297 | |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 298 | static const char *wt_status_diff_status_string(int status) |
| 299 | { |
| 300 | switch (status) { |
| 301 | case DIFF_STATUS_ADDED: |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 302 | return _("new file:"); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 303 | case DIFF_STATUS_COPIED: |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 304 | return _("copied:"); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 305 | case DIFF_STATUS_DELETED: |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 306 | return _("deleted:"); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 307 | case DIFF_STATUS_MODIFIED: |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 308 | return _("modified:"); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 309 | case DIFF_STATUS_RENAMED: |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 310 | return _("renamed:"); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 311 | case DIFF_STATUS_TYPE_CHANGED: |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 312 | return _("typechange:"); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 313 | case DIFF_STATUS_UNKNOWN: |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 314 | return _("unknown:"); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 315 | case DIFF_STATUS_UNMERGED: |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 316 | return _("unmerged:"); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 317 | default: |
| 318 | return NULL; |
| 319 | } |
| 320 | } |
| 321 | |
Jonathan Nieder | 335e825 | 2013-12-19 11:43:19 -0800 | [diff] [blame] | 322 | static int maxwidth(const char *(*label)(int), int minval, int maxval) |
| 323 | { |
| 324 | int result = 0, i; |
| 325 | |
| 326 | for (i = minval; i <= maxval; i++) { |
| 327 | const char *s = label(i); |
| 328 | int len = s ? utf8_strwidth(s) : 0; |
| 329 | if (len > result) |
| 330 | result = len; |
| 331 | } |
| 332 | return result; |
| 333 | } |
| 334 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 335 | static void wt_longstatus_print_unmerged_data(struct wt_status *s, |
| 336 | struct string_list_item *it) |
Jonathan Nieder | 8f17f5b | 2013-12-19 11:43:19 -0800 | [diff] [blame] | 337 | { |
| 338 | const char *c = color(WT_STATUS_UNMERGED, s); |
| 339 | struct wt_status_change_data *d = it->util; |
| 340 | struct strbuf onebuf = STRBUF_INIT; |
| 341 | static char *padding; |
| 342 | static int label_width; |
| 343 | const char *one, *how; |
| 344 | int len; |
| 345 | |
| 346 | if (!padding) { |
| 347 | label_width = maxwidth(wt_status_unmerged_status_string, 1, 7); |
| 348 | label_width += strlen(" "); |
Jonathan Nieder | 8f17f5b | 2013-12-19 11:43:19 -0800 | [diff] [blame] | 349 | padding = xmallocz(label_width); |
| 350 | memset(padding, ' ', label_width); |
| 351 | } |
| 352 | |
Junio C Hamano | 88910c9 | 2020-09-10 10:01:54 -0700 | [diff] [blame] | 353 | one = quote_path(it->string, s->prefix, &onebuf, 0); |
Jonathan Nieder | 8f17f5b | 2013-12-19 11:43:19 -0800 | [diff] [blame] | 354 | status_printf(s, color(WT_STATUS_HEADER, s), "\t"); |
| 355 | |
| 356 | how = wt_status_unmerged_status_string(d->stagemask); |
| 357 | len = label_width - utf8_strwidth(how); |
| 358 | status_printf_more(s, c, "%s%.*s%s\n", how, len, padding, one); |
| 359 | strbuf_release(&onebuf); |
| 360 | } |
| 361 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 362 | static void wt_longstatus_print_change_data(struct wt_status *s, |
| 363 | int change_type, |
| 364 | struct string_list_item *it) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 365 | { |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 366 | struct wt_status_change_data *d = it->util; |
Junio C Hamano | d249b09 | 2009-08-09 21:59:30 -0700 | [diff] [blame] | 367 | const char *c = color(change_type, s); |
Jeff King | b8527d5 | 2013-03-21 07:05:28 -0400 | [diff] [blame] | 368 | int status; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 369 | char *one_name; |
| 370 | char *two_name; |
Junio C Hamano | 3a94680 | 2006-11-08 13:20:46 -0800 | [diff] [blame] | 371 | const char *one, *two; |
Brandon Casey | f285a2d | 2008-10-09 14:12:12 -0500 | [diff] [blame] | 372 | struct strbuf onebuf = STRBUF_INIT, twobuf = STRBUF_INIT; |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 373 | struct strbuf extra = STRBUF_INIT; |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 374 | static char *padding; |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 375 | static int label_width; |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 376 | const char *what; |
| 377 | int len; |
| 378 | |
| 379 | if (!padding) { |
Jonathan Nieder | 335e825 | 2013-12-19 11:43:19 -0800 | [diff] [blame] | 380 | /* If DIFF_STATUS_* uses outside the range [A..Z], we're in trouble */ |
| 381 | label_width = maxwidth(wt_status_diff_status_string, 'A', 'Z'); |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 382 | label_width += strlen(" "); |
| 383 | padding = xmallocz(label_width); |
| 384 | memset(padding, ' ', label_width); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 385 | } |
Junio C Hamano | 3a94680 | 2006-11-08 13:20:46 -0800 | [diff] [blame] | 386 | |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 387 | one_name = two_name = it->string; |
| 388 | switch (change_type) { |
| 389 | case WT_STATUS_UPDATED: |
| 390 | status = d->index_status; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 391 | break; |
| 392 | case WT_STATUS_CHANGED: |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 393 | if (d->new_submodule_commits || d->dirty_submodule) { |
| 394 | strbuf_addstr(&extra, " ("); |
| 395 | if (d->new_submodule_commits) |
René Scharfe | a22ae75 | 2016-09-15 20:31:00 +0200 | [diff] [blame] | 396 | strbuf_addstr(&extra, _("new commits, ")); |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 397 | if (d->dirty_submodule & DIRTY_SUBMODULE_MODIFIED) |
René Scharfe | a22ae75 | 2016-09-15 20:31:00 +0200 | [diff] [blame] | 398 | strbuf_addstr(&extra, _("modified content, ")); |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 399 | if (d->dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) |
René Scharfe | a22ae75 | 2016-09-15 20:31:00 +0200 | [diff] [blame] | 400 | strbuf_addstr(&extra, _("untracked content, ")); |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 401 | strbuf_setlen(&extra, extra.len - 2); |
| 402 | strbuf_addch(&extra, ')'); |
| 403 | } |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 404 | status = d->worktree_status; |
| 405 | break; |
Jeff King | b8527d5 | 2013-03-21 07:05:28 -0400 | [diff] [blame] | 406 | default: |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 407 | BUG("unhandled change_type %d in wt_longstatus_print_change_data", |
Jeff King | b8527d5 | 2013-03-21 07:05:28 -0400 | [diff] [blame] | 408 | change_type); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 409 | } |
| 410 | |
Nguyễn Thái Ngọc Duy | 176ea74 | 2017-12-27 17:18:39 +0700 | [diff] [blame] | 411 | /* |
| 412 | * Only pick up the rename it's relevant. If the rename is for |
| 413 | * the changed section and we're printing the updated section, |
| 414 | * ignore it. |
| 415 | */ |
| 416 | if (d->rename_status == status) |
| 417 | one_name = d->rename_source; |
| 418 | |
Junio C Hamano | 88910c9 | 2020-09-10 10:01:54 -0700 | [diff] [blame] | 419 | one = quote_path(one_name, s->prefix, &onebuf, 0); |
| 420 | two = quote_path(two_name, s->prefix, &twobuf, 0); |
Junio C Hamano | 3a94680 | 2006-11-08 13:20:46 -0800 | [diff] [blame] | 421 | |
Jonathan Nieder | b926c0d | 2011-02-25 23:11:37 -0600 | [diff] [blame] | 422 | status_printf(s, color(WT_STATUS_HEADER, s), "\t"); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 423 | what = wt_status_diff_status_string(status); |
| 424 | if (!what) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 425 | BUG("unhandled diff status %c", status); |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 426 | len = label_width - utf8_strwidth(what); |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 427 | assert(len >= 0); |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 428 | if (one_name != two_name) |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 429 | status_printf_more(s, c, "%s%.*s%s -> %s", |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 430 | what, len, padding, one, two); |
| 431 | else |
Junio C Hamano | d52cb57 | 2014-03-12 13:51:22 -0700 | [diff] [blame] | 432 | status_printf_more(s, c, "%s%.*s%s", |
Nguyễn Thái Ngọc Duy | 3651e45 | 2013-11-05 09:07:29 +0700 | [diff] [blame] | 433 | what, len, padding, one); |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 434 | if (extra.len) { |
Jonathan Nieder | b926c0d | 2011-02-25 23:11:37 -0600 | [diff] [blame] | 435 | status_printf_more(s, color(WT_STATUS_HEADER, s), "%s", extra.buf); |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 436 | strbuf_release(&extra); |
| 437 | } |
Jonathan Nieder | b926c0d | 2011-02-25 23:11:37 -0600 | [diff] [blame] | 438 | status_printf_more(s, GIT_COLOR_NORMAL, "\n"); |
Johannes Schindelin | 367c988 | 2007-11-11 17:35:41 +0000 | [diff] [blame] | 439 | strbuf_release(&onebuf); |
| 440 | strbuf_release(&twobuf); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 441 | } |
| 442 | |
Nguyễn Thái Ngọc Duy | 98bc94e | 2017-12-27 17:18:36 +0700 | [diff] [blame] | 443 | static char short_submodule_status(struct wt_status_change_data *d) |
| 444 | { |
Stefan Beller | dd6962d | 2017-03-29 15:26:15 -0700 | [diff] [blame] | 445 | if (d->new_submodule_commits) |
| 446 | return 'M'; |
| 447 | if (d->dirty_submodule & DIRTY_SUBMODULE_MODIFIED) |
| 448 | return 'm'; |
| 449 | if (d->dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) |
| 450 | return '?'; |
| 451 | return d->worktree_status; |
| 452 | } |
| 453 | |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 454 | static void wt_status_collect_changed_cb(struct diff_queue_struct *q, |
Jeff King | 61bdc7c | 2022-12-13 06:13:48 -0500 | [diff] [blame] | 455 | struct diff_options *options UNUSED, |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 456 | void *data) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 457 | { |
| 458 | struct wt_status *s = data; |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 459 | int i; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 460 | |
| 461 | if (!q->nr) |
| 462 | return; |
| 463 | s->workdir_dirty = 1; |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 464 | for (i = 0; i < q->nr; i++) { |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 465 | struct diff_filepair *p; |
| 466 | struct string_list_item *it; |
| 467 | struct wt_status_change_data *d; |
| 468 | |
| 469 | p = q->queue[i]; |
Nguyễn Thái Ngọc Duy | 176ea74 | 2017-12-27 17:18:39 +0700 | [diff] [blame] | 470 | it = string_list_insert(&s->change, p->two->path); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 471 | d = it->util; |
| 472 | if (!d) { |
René Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 473 | CALLOC_ARRAY(d, 1); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 474 | it->util = d; |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 475 | } |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 476 | if (!d->worktree_status) |
| 477 | d->worktree_status = p->status; |
Stefan Beller | dd6962d | 2017-03-29 15:26:15 -0700 | [diff] [blame] | 478 | if (S_ISGITLINK(p->two->mode)) { |
| 479 | d->dirty_submodule = p->two->dirty_submodule; |
Jeff King | 4a7e27e | 2018-08-28 17:22:40 -0400 | [diff] [blame] | 480 | d->new_submodule_commits = !oideq(&p->one->oid, |
| 481 | &p->two->oid); |
Stefan Beller | dd6962d | 2017-03-29 15:26:15 -0700 | [diff] [blame] | 482 | if (s->status_format == STATUS_FORMAT_SHORT) |
| 483 | d->worktree_status = short_submodule_status(d); |
| 484 | } |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 485 | |
| 486 | switch (p->status) { |
| 487 | case DIFF_STATUS_ADDED: |
Nguyễn Thái Ngọc Duy | 425a28e | 2016-10-24 17:42:19 +0700 | [diff] [blame] | 488 | d->mode_worktree = p->two->mode; |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 489 | break; |
| 490 | |
| 491 | case DIFF_STATUS_DELETED: |
| 492 | d->mode_index = p->one->mode; |
| 493 | oidcpy(&d->oid_index, &p->one->oid); |
| 494 | /* mode_worktree is zero for a delete. */ |
| 495 | break; |
| 496 | |
Nguyễn Thái Ngọc Duy | 176ea74 | 2017-12-27 17:18:39 +0700 | [diff] [blame] | 497 | case DIFF_STATUS_COPIED: |
| 498 | case DIFF_STATUS_RENAMED: |
| 499 | if (d->rename_status) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 500 | BUG("multiple renames on the same target? how?"); |
Nguyễn Thái Ngọc Duy | 176ea74 | 2017-12-27 17:18:39 +0700 | [diff] [blame] | 501 | d->rename_source = xstrdup(p->one->path); |
| 502 | d->rename_score = p->score * 100 / MAX_SCORE; |
| 503 | d->rename_status = p->status; |
| 504 | /* fallthru */ |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 505 | case DIFF_STATUS_MODIFIED: |
| 506 | case DIFF_STATUS_TYPE_CHANGED: |
| 507 | case DIFF_STATUS_UNMERGED: |
| 508 | d->mode_index = p->one->mode; |
| 509 | d->mode_worktree = p->two->mode; |
| 510 | oidcpy(&d->oid_index, &p->one->oid); |
| 511 | break; |
| 512 | |
Nguyễn Thái Ngọc Duy | ea56f97 | 2017-12-27 17:18:37 +0700 | [diff] [blame] | 513 | default: |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 514 | BUG("unhandled diff-files status '%c'", p->status); |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 515 | break; |
| 516 | } |
| 517 | |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 518 | } |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 519 | } |
| 520 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 521 | static int unmerged_mask(struct index_state *istate, const char *path) |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 522 | { |
| 523 | int pos, mask; |
Nguyễn Thái Ngọc Duy | 9c5e6c8 | 2013-07-09 22:29:00 +0700 | [diff] [blame] | 524 | const struct cache_entry *ce; |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 525 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 526 | pos = index_name_pos(istate, path, strlen(path)); |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 527 | if (0 <= pos) |
| 528 | return 0; |
| 529 | |
| 530 | mask = 0; |
| 531 | pos = -pos-1; |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 532 | while (pos < istate->cache_nr) { |
| 533 | ce = istate->cache[pos++]; |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 534 | if (strcmp(ce->name, path) || !ce_stage(ce)) |
| 535 | break; |
| 536 | mask |= (1 << (ce_stage(ce) - 1)); |
| 537 | } |
| 538 | return mask; |
| 539 | } |
| 540 | |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 541 | static void wt_status_collect_updated_cb(struct diff_queue_struct *q, |
Jeff King | 61bdc7c | 2022-12-13 06:13:48 -0500 | [diff] [blame] | 542 | struct diff_options *options UNUSED, |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 543 | void *data) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 544 | { |
Jürgen Rühle | 6e458bf | 2007-01-02 20:26:22 +0100 | [diff] [blame] | 545 | struct wt_status *s = data; |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 546 | int i; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 547 | |
| 548 | for (i = 0; i < q->nr; i++) { |
| 549 | struct diff_filepair *p; |
| 550 | struct string_list_item *it; |
| 551 | struct wt_status_change_data *d; |
| 552 | |
| 553 | p = q->queue[i]; |
Julian Phillips | 78a395d | 2010-06-26 00:41:35 +0100 | [diff] [blame] | 554 | it = string_list_insert(&s->change, p->two->path); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 555 | d = it->util; |
| 556 | if (!d) { |
René Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 557 | CALLOC_ARRAY(d, 1); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 558 | it->util = d; |
| 559 | } |
| 560 | if (!d->index_status) |
| 561 | d->index_status = p->status; |
| 562 | switch (p->status) { |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 563 | case DIFF_STATUS_ADDED: |
| 564 | /* Leave {mode,oid}_head zero for an add. */ |
| 565 | d->mode_index = p->two->mode; |
| 566 | oidcpy(&d->oid_index, &p->two->oid); |
Stephen P. Smith | f3bd35f | 2018-09-05 17:53:29 -0700 | [diff] [blame] | 567 | s->committable = 1; |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 568 | break; |
| 569 | case DIFF_STATUS_DELETED: |
| 570 | d->mode_head = p->one->mode; |
| 571 | oidcpy(&d->oid_head, &p->one->oid); |
Stephen P. Smith | f3bd35f | 2018-09-05 17:53:29 -0700 | [diff] [blame] | 572 | s->committable = 1; |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 573 | /* Leave {mode,oid}_index zero for a delete. */ |
| 574 | break; |
| 575 | |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 576 | case DIFF_STATUS_COPIED: |
| 577 | case DIFF_STATUS_RENAMED: |
Nguyễn Thái Ngọc Duy | 176ea74 | 2017-12-27 17:18:39 +0700 | [diff] [blame] | 578 | if (d->rename_status) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 579 | BUG("multiple renames on the same target? how?"); |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 580 | d->rename_source = xstrdup(p->one->path); |
| 581 | d->rename_score = p->score * 100 / MAX_SCORE; |
| 582 | d->rename_status = p->status; |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 583 | /* fallthru */ |
| 584 | case DIFF_STATUS_MODIFIED: |
| 585 | case DIFF_STATUS_TYPE_CHANGED: |
| 586 | d->mode_head = p->one->mode; |
| 587 | d->mode_index = p->two->mode; |
| 588 | oidcpy(&d->oid_head, &p->one->oid); |
| 589 | oidcpy(&d->oid_index, &p->two->oid); |
Stephen P. Smith | f3bd35f | 2018-09-05 17:53:29 -0700 | [diff] [blame] | 590 | s->committable = 1; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 591 | break; |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 592 | case DIFF_STATUS_UNMERGED: |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 593 | d->stagemask = unmerged_mask(s->repo->index, |
| 594 | p->two->path); |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 595 | /* |
| 596 | * Don't bother setting {mode,oid}_{head,index} since the print |
| 597 | * code will output the stage values directly and not use the |
| 598 | * values in these fields. |
| 599 | */ |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 600 | break; |
Nguyễn Thái Ngọc Duy | ea56f97 | 2017-12-27 17:18:37 +0700 | [diff] [blame] | 601 | |
| 602 | default: |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 603 | BUG("unhandled diff-index status '%c'", p->status); |
Nguyễn Thái Ngọc Duy | ea56f97 | 2017-12-27 17:18:37 +0700 | [diff] [blame] | 604 | break; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 605 | } |
Jürgen Rühle | 6e458bf | 2007-01-02 20:26:22 +0100 | [diff] [blame] | 606 | } |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 607 | } |
| 608 | |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 609 | static void wt_status_collect_changes_worktree(struct wt_status *s) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 610 | { |
| 611 | struct rev_info rev; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 612 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 613 | repo_init_revisions(s->repo, &rev, NULL); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 614 | setup_revisions(0, NULL, &rev, NULL); |
| 615 | rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK; |
Brandon Williams | 0d1e0e7 | 2017-10-31 11:19:11 -0700 | [diff] [blame] | 616 | rev.diffopt.flags.dirty_submodules = 1; |
Nguyễn Thái Ngọc Duy | 425a28e | 2016-10-24 17:42:19 +0700 | [diff] [blame] | 617 | rev.diffopt.ita_invisible_in_index = 1; |
Jens Lehmann | 3bfc450 | 2010-03-13 23:00:27 +0100 | [diff] [blame] | 618 | if (!s->show_untracked_files) |
Brandon Williams | 0d1e0e7 | 2017-10-31 11:19:11 -0700 | [diff] [blame] | 619 | rev.diffopt.flags.ignore_untracked_in_submodules = 1; |
Jens Lehmann | aee9c7d | 2010-08-06 00:39:25 +0200 | [diff] [blame] | 620 | if (s->ignore_submodule_arg) { |
Brandon Williams | 0d1e0e7 | 2017-10-31 11:19:11 -0700 | [diff] [blame] | 621 | rev.diffopt.flags.override_submodule_config = 1; |
Jens Lehmann | 46a958b | 2010-06-25 16:56:47 +0200 | [diff] [blame] | 622 | handle_ignore_submodules_arg(&rev.diffopt, s->ignore_submodule_arg); |
Sangeeta Jain | 8ef9312 | 2020-11-10 14:09:00 +0530 | [diff] [blame] | 623 | } else if (!rev.diffopt.flags.ignore_submodule_set && |
| 624 | s->show_untracked_files != SHOW_NO_UNTRACKED_FILES) |
| 625 | handle_ignore_submodules_arg(&rev.diffopt, "none"); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 626 | rev.diffopt.format_callback = wt_status_collect_changed_cb; |
| 627 | rev.diffopt.format_callback_data = s; |
Ben Peart | e8b2dc2 | 2018-05-11 15:38:58 +0000 | [diff] [blame] | 628 | rev.diffopt.detect_rename = s->detect_rename >= 0 ? s->detect_rename : rev.diffopt.detect_rename; |
| 629 | rev.diffopt.rename_limit = s->rename_limit >= 0 ? s->rename_limit : rev.diffopt.rename_limit; |
| 630 | rev.diffopt.rename_score = s->rename_score >= 0 ? s->rename_score : rev.diffopt.rename_score; |
Nguyễn Thái Ngọc Duy | 15b55ae | 2013-07-14 15:35:39 +0700 | [diff] [blame] | 631 | copy_pathspec(&rev.prune_data, &s->pathspec); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 632 | run_diff_files(&rev, 0); |
Ævar Arnfjörð Bjarmason | f0cb6b8 | 2022-04-13 22:01:44 +0200 | [diff] [blame] | 633 | release_revisions(&rev); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 634 | } |
| 635 | |
| 636 | static void wt_status_collect_changes_index(struct wt_status *s) |
| 637 | { |
| 638 | struct rev_info rev; |
Junio C Hamano | 32962c9 | 2010-03-08 22:58:09 -0800 | [diff] [blame] | 639 | struct setup_revision_opt opt; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 640 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 641 | repo_init_revisions(s->repo, &rev, NULL); |
Junio C Hamano | 32962c9 | 2010-03-08 22:58:09 -0800 | [diff] [blame] | 642 | memset(&opt, 0, sizeof(opt)); |
brian m. carlson | f2e5119 | 2018-05-02 00:26:00 +0000 | [diff] [blame] | 643 | opt.def = s->is_initial ? empty_tree_oid_hex() : s->reference; |
Junio C Hamano | 32962c9 | 2010-03-08 22:58:09 -0800 | [diff] [blame] | 644 | setup_revisions(0, NULL, &rev, &opt); |
| 645 | |
Brandon Williams | 0d1e0e7 | 2017-10-31 11:19:11 -0700 | [diff] [blame] | 646 | rev.diffopt.flags.override_submodule_config = 1; |
Nguyễn Thái Ngọc Duy | 425a28e | 2016-10-24 17:42:19 +0700 | [diff] [blame] | 647 | rev.diffopt.ita_invisible_in_index = 1; |
Jens Lehmann | aee9c7d | 2010-08-06 00:39:25 +0200 | [diff] [blame] | 648 | if (s->ignore_submodule_arg) { |
Jens Lehmann | 46a958b | 2010-06-25 16:56:47 +0200 | [diff] [blame] | 649 | handle_ignore_submodules_arg(&rev.diffopt, s->ignore_submodule_arg); |
Jens Lehmann | 1d2f393 | 2014-04-05 18:59:03 +0200 | [diff] [blame] | 650 | } else { |
| 651 | /* |
| 652 | * Unless the user did explicitly request a submodule ignore |
| 653 | * mode by passing a command line option we do not ignore any |
| 654 | * changed submodule SHA-1s when comparing index and HEAD, no |
| 655 | * matter what is configured. Otherwise the user won't be |
Felipe Contreras | 0e20b22 | 2021-06-15 14:11:10 +0000 | [diff] [blame] | 656 | * shown any submodules manually added (and which are |
Jens Lehmann | 1d2f393 | 2014-04-05 18:59:03 +0200 | [diff] [blame] | 657 | * staged to be committed), which would be really confusing. |
| 658 | */ |
| 659 | handle_ignore_submodules_arg(&rev.diffopt, "dirty"); |
Jens Lehmann | aee9c7d | 2010-08-06 00:39:25 +0200 | [diff] [blame] | 660 | } |
Jens Lehmann | 46a958b | 2010-06-25 16:56:47 +0200 | [diff] [blame] | 661 | |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 662 | rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 663 | rev.diffopt.format_callback = wt_status_collect_updated_cb; |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 664 | rev.diffopt.format_callback_data = s; |
Ben Peart | e8b2dc2 | 2018-05-11 15:38:58 +0000 | [diff] [blame] | 665 | rev.diffopt.detect_rename = s->detect_rename >= 0 ? s->detect_rename : rev.diffopt.detect_rename; |
| 666 | rev.diffopt.rename_limit = s->rename_limit >= 0 ? s->rename_limit : rev.diffopt.rename_limit; |
| 667 | rev.diffopt.rename_score = s->rename_score >= 0 ? s->rename_score : rev.diffopt.rename_score; |
Victoria Dye | 2c521b0 | 2022-03-01 20:24:25 +0000 | [diff] [blame] | 668 | |
| 669 | /* |
| 670 | * The `recursive` option must be enabled to allow the diff to recurse |
| 671 | * into subdirectories of sparse directory index entries. If it is not |
| 672 | * enabled, a subdirectory containing file(s) with changes is reported |
| 673 | * as "modified", rather than the modified files themselves. |
| 674 | */ |
| 675 | rev.diffopt.flags.recursive = 1; |
| 676 | |
Nguyễn Thái Ngọc Duy | 15b55ae | 2013-07-14 15:35:39 +0700 | [diff] [blame] | 677 | copy_pathspec(&rev.prune_data, &s->pathspec); |
Junio C Hamano | 976b97e | 2023-08-21 16:14:14 -0400 | [diff] [blame] | 678 | run_diff_index(&rev, DIFF_INDEX_CACHED); |
Ævar Arnfjörð Bjarmason | 1878b5e | 2022-04-13 22:01:35 +0200 | [diff] [blame] | 679 | release_revisions(&rev); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 680 | } |
| 681 | |
Derrick Stolee | fe0d576 | 2021-07-14 13:12:38 +0000 | [diff] [blame] | 682 | static int add_file_to_list(const struct object_id *oid, |
| 683 | struct strbuf *base, const char *path, |
| 684 | unsigned int mode, void *context) |
| 685 | { |
| 686 | struct string_list_item *it; |
| 687 | struct wt_status_change_data *d; |
| 688 | struct wt_status *s = context; |
| 689 | struct strbuf full_name = STRBUF_INIT; |
| 690 | |
| 691 | if (S_ISDIR(mode)) |
| 692 | return READ_TREE_RECURSIVE; |
| 693 | |
| 694 | strbuf_add(&full_name, base->buf, base->len); |
| 695 | strbuf_addstr(&full_name, path); |
| 696 | it = string_list_insert(&s->change, full_name.buf); |
| 697 | d = it->util; |
| 698 | if (!d) { |
| 699 | CALLOC_ARRAY(d, 1); |
| 700 | it->util = d; |
| 701 | } |
| 702 | |
| 703 | d->index_status = DIFF_STATUS_ADDED; |
| 704 | /* Leave {mode,oid}_head zero for adds. */ |
| 705 | d->mode_index = mode; |
| 706 | oidcpy(&d->oid_index, oid); |
| 707 | s->committable = 1; |
| 708 | strbuf_release(&full_name); |
| 709 | return 0; |
| 710 | } |
| 711 | |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 712 | static void wt_status_collect_changes_initial(struct wt_status *s) |
| 713 | { |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 714 | struct index_state *istate = s->repo->index; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 715 | int i; |
| 716 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 717 | for (i = 0; i < istate->cache_nr; i++) { |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 718 | struct string_list_item *it; |
| 719 | struct wt_status_change_data *d; |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 720 | const struct cache_entry *ce = istate->cache[i]; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 721 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 722 | if (!ce_path_match(istate, ce, &s->pathspec, NULL)) |
Junio C Hamano | 76e2f7c | 2009-08-07 23:31:57 -0700 | [diff] [blame] | 723 | continue; |
Nguyễn Thái Ngọc Duy | 425a28e | 2016-10-24 17:42:19 +0700 | [diff] [blame] | 724 | if (ce_intent_to_add(ce)) |
| 725 | continue; |
Derrick Stolee | fe0d576 | 2021-07-14 13:12:38 +0000 | [diff] [blame] | 726 | if (S_ISSPARSEDIR(ce->ce_mode)) { |
| 727 | /* |
| 728 | * This is a sparse directory entry, so we want to collect all |
| 729 | * of the added files within the tree. This requires recursively |
| 730 | * expanding the trees to find the elements that are new in this |
| 731 | * tree and marking them with DIFF_STATUS_ADDED. |
| 732 | */ |
| 733 | struct strbuf base = STRBUF_INIT; |
| 734 | struct pathspec ps = { 0 }; |
| 735 | struct tree *tree = lookup_tree(istate->repo, &ce->oid); |
| 736 | |
| 737 | ps.recursive = 1; |
| 738 | ps.has_wildcard = 1; |
| 739 | ps.max_depth = -1; |
| 740 | |
| 741 | strbuf_add(&base, ce->name, ce->ce_namelen); |
| 742 | read_tree_at(istate->repo, tree, &base, &ps, |
| 743 | add_file_to_list, s); |
| 744 | continue; |
| 745 | } |
| 746 | |
Julian Phillips | 78a395d | 2010-06-26 00:41:35 +0100 | [diff] [blame] | 747 | it = string_list_insert(&s->change, ce->name); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 748 | d = it->util; |
| 749 | if (!d) { |
René Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 750 | CALLOC_ARRAY(d, 1); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 751 | it->util = d; |
| 752 | } |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 753 | if (ce_stage(ce)) { |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 754 | d->index_status = DIFF_STATUS_UNMERGED; |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 755 | d->stagemask |= (1 << (ce_stage(ce) - 1)); |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 756 | /* |
| 757 | * Don't bother setting {mode,oid}_{head,index} since the print |
| 758 | * code will output the stage values directly and not use the |
| 759 | * values in these fields. |
| 760 | */ |
Stephen P. Smith | f3bd35f | 2018-09-05 17:53:29 -0700 | [diff] [blame] | 761 | s->committable = 1; |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 762 | } else { |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 763 | d->index_status = DIFF_STATUS_ADDED; |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 764 | /* Leave {mode,oid}_head zero for adds. */ |
| 765 | d->mode_index = ce->ce_mode; |
René Scharfe | 8694769 | 2017-01-28 23:03:06 +0100 | [diff] [blame] | 766 | oidcpy(&d->oid_index, &ce->oid); |
Stephen P. Smith | f3bd35f | 2018-09-05 17:53:29 -0700 | [diff] [blame] | 767 | s->committable = 1; |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 768 | } |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 769 | } |
| 770 | } |
| 771 | |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 772 | static void wt_status_collect_untracked(struct wt_status *s) |
| 773 | { |
| 774 | int i; |
Ævar Arnfjörð Bjarmason | ce93a4c | 2021-07-01 12:51:27 +0200 | [diff] [blame] | 775 | struct dir_struct dir = DIR_INIT; |
Karsten Blees | 132d41e | 2014-07-12 02:07:36 +0200 | [diff] [blame] | 776 | uint64_t t_begin = getnanotime(); |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 777 | struct index_state *istate = s->repo->index; |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 778 | |
| 779 | if (!s->show_untracked_files) |
| 780 | return; |
Nguyễn Thái Ngọc Duy | 6a38ef2 | 2013-03-13 19:59:16 +0700 | [diff] [blame] | 781 | |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 782 | if (s->show_untracked_files != SHOW_ALL_UNTRACKED_FILES) |
| 783 | dir.flags |= |
| 784 | DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES; |
Jameson Miller | eec0f7f | 2017-10-30 13:21:37 -0400 | [diff] [blame] | 785 | if (s->show_ignored_mode) { |
Karsten Blees | 0aaf62b | 2013-04-15 21:15:03 +0200 | [diff] [blame] | 786 | dir.flags |= DIR_SHOW_IGNORED_TOO; |
Jameson Miller | eec0f7f | 2017-10-30 13:21:37 -0400 | [diff] [blame] | 787 | |
| 788 | if (s->show_ignored_mode == SHOW_MATCHING_IGNORED) |
| 789 | dir.flags |= DIR_SHOW_IGNORED_TOO_MODE_MATCHING; |
| 790 | } else { |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 791 | dir.untracked = istate->untracked; |
Jameson Miller | eec0f7f | 2017-10-30 13:21:37 -0400 | [diff] [blame] | 792 | } |
| 793 | |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 794 | setup_standard_excludes(&dir); |
| 795 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 796 | fill_directory(&dir, istate, &s->pathspec); |
Karsten Blees | 0aaf62b | 2013-04-15 21:15:03 +0200 | [diff] [blame] | 797 | |
Brian Gianforcaro | eeefa7c | 2009-09-01 01:35:10 -0400 | [diff] [blame] | 798 | for (i = 0; i < dir.nr; i++) { |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 799 | struct dir_entry *ent = dir.entries[i]; |
Elijah Newren | 95c11ec | 2020-04-01 04:17:45 +0000 | [diff] [blame] | 800 | if (index_name_is_other(istate, ent->name, ent->len)) |
Brandon Casey | b822423 | 2010-09-26 21:49:13 -0500 | [diff] [blame] | 801 | string_list_insert(&s->untracked, ent->name); |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 802 | } |
Junio C Hamano | f5b26b1 | 2010-04-09 23:58:27 -0700 | [diff] [blame] | 803 | |
Karsten Blees | 0aaf62b | 2013-04-15 21:15:03 +0200 | [diff] [blame] | 804 | for (i = 0; i < dir.ignored_nr; i++) { |
| 805 | struct dir_entry *ent = dir.ignored[i]; |
Elijah Newren | 95c11ec | 2020-04-01 04:17:45 +0000 | [diff] [blame] | 806 | if (index_name_is_other(istate, ent->name, ent->len)) |
Karsten Blees | 0aaf62b | 2013-04-15 21:15:03 +0200 | [diff] [blame] | 807 | string_list_insert(&s->ignored, ent->name); |
Junio C Hamano | 6cb3f6b | 2010-04-10 00:11:53 -0700 | [diff] [blame] | 808 | } |
| 809 | |
Elijah Newren | eceba53 | 2020-08-18 22:58:26 +0000 | [diff] [blame] | 810 | dir_clear(&dir); |
Nguyễn Thái Ngọc Duy | 6a38ef2 | 2013-03-13 19:59:16 +0700 | [diff] [blame] | 811 | |
Ben Boeckel | ed9bff0 | 2021-08-23 12:44:00 +0200 | [diff] [blame] | 812 | if (advice_enabled(ADVICE_STATUS_U_OPTION)) |
Karsten Blees | 132d41e | 2014-07-12 02:07:36 +0200 | [diff] [blame] | 813 | s->untracked_in_ms = (getnanotime() - t_begin) / 1000000; |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 814 | } |
| 815 | |
Stephen P. Smith | c01d8f9 | 2018-09-05 17:53:26 -0700 | [diff] [blame] | 816 | static int has_unmerged(struct wt_status *s) |
| 817 | { |
| 818 | int i; |
| 819 | |
| 820 | for (i = 0; i < s->change.nr; i++) { |
| 821 | struct wt_status_change_data *d; |
| 822 | d = s->change.items[i].util; |
| 823 | if (d->stagemask) |
| 824 | return 1; |
| 825 | } |
| 826 | return 0; |
| 827 | } |
| 828 | |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 829 | void wt_status_collect(struct wt_status *s) |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 830 | { |
Jeff Hostetler | 942b274 | 2019-02-22 14:25:03 -0800 | [diff] [blame] | 831 | trace2_region_enter("status", "worktrees", s->repo); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 832 | wt_status_collect_changes_worktree(s); |
Jeff Hostetler | 942b274 | 2019-02-22 14:25:03 -0800 | [diff] [blame] | 833 | trace2_region_leave("status", "worktrees", s->repo); |
| 834 | |
| 835 | if (s->is_initial) { |
| 836 | trace2_region_enter("status", "initial", s->repo); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 837 | wt_status_collect_changes_initial(s); |
Jeff Hostetler | 942b274 | 2019-02-22 14:25:03 -0800 | [diff] [blame] | 838 | trace2_region_leave("status", "initial", s->repo); |
| 839 | } else { |
| 840 | trace2_region_enter("status", "index", s->repo); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 841 | wt_status_collect_changes_index(s); |
Jeff Hostetler | 942b274 | 2019-02-22 14:25:03 -0800 | [diff] [blame] | 842 | trace2_region_leave("status", "index", s->repo); |
| 843 | } |
| 844 | |
| 845 | trace2_region_enter("status", "untracked", s->repo); |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 846 | wt_status_collect_untracked(s); |
Jeff Hostetler | 942b274 | 2019-02-22 14:25:03 -0800 | [diff] [blame] | 847 | trace2_region_leave("status", "untracked", s->repo); |
Stephen P. Smith | f3bd35f | 2018-09-05 17:53:29 -0700 | [diff] [blame] | 848 | |
Nguyễn Thái Ngọc Duy | 7884545 | 2018-11-10 06:48:50 +0100 | [diff] [blame] | 849 | wt_status_get_state(s->repo, &s->state, s->branch && !strcmp(s->branch, "HEAD")); |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 850 | if (s->state.merge_in_progress && !has_unmerged(s)) |
Stephen P. Smith | f3bd35f | 2018-09-05 17:53:29 -0700 | [diff] [blame] | 851 | s->committable = 1; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 852 | } |
| 853 | |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 854 | void wt_status_collect_free_buffers(struct wt_status *s) |
| 855 | { |
Martin Ågren | 962dd7e | 2020-09-27 15:15:43 +0200 | [diff] [blame] | 856 | wt_status_state_free_buffers(&s->state); |
| 857 | } |
| 858 | |
| 859 | void wt_status_state_free_buffers(struct wt_status_state *state) |
| 860 | { |
| 861 | FREE_AND_NULL(state->branch); |
| 862 | FREE_AND_NULL(state->onto); |
| 863 | FREE_AND_NULL(state->detached_from); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 864 | } |
| 865 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 866 | static void wt_longstatus_print_unmerged(struct wt_status *s) |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 867 | { |
| 868 | int shown_header = 0; |
| 869 | int i; |
| 870 | |
| 871 | for (i = 0; i < s->change.nr; i++) { |
| 872 | struct wt_status_change_data *d; |
| 873 | struct string_list_item *it; |
| 874 | it = &(s->change.items[i]); |
| 875 | d = it->util; |
| 876 | if (!d->stagemask) |
| 877 | continue; |
| 878 | if (!shown_header) { |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 879 | wt_longstatus_print_unmerged_header(s); |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 880 | shown_header = 1; |
| 881 | } |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 882 | wt_longstatus_print_unmerged_data(s, it); |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 883 | } |
| 884 | if (shown_header) |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 885 | wt_longstatus_print_trailer(s); |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 886 | |
| 887 | } |
| 888 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 889 | static void wt_longstatus_print_updated(struct wt_status *s) |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 890 | { |
| 891 | int shown_header = 0; |
| 892 | int i; |
| 893 | |
| 894 | for (i = 0; i < s->change.nr; i++) { |
| 895 | struct wt_status_change_data *d; |
| 896 | struct string_list_item *it; |
| 897 | it = &(s->change.items[i]); |
| 898 | d = it->util; |
| 899 | if (!d->index_status || |
| 900 | d->index_status == DIFF_STATUS_UNMERGED) |
| 901 | continue; |
| 902 | if (!shown_header) { |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 903 | wt_longstatus_print_cached_header(s); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 904 | shown_header = 1; |
| 905 | } |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 906 | wt_longstatus_print_change_data(s, WT_STATUS_UPDATED, it); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 907 | } |
| 908 | if (shown_header) |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 909 | wt_longstatus_print_trailer(s); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 910 | } |
| 911 | |
| 912 | /* |
| 913 | * -1 : has delete |
| 914 | * 0 : no change |
| 915 | * 1 : some change but no delete |
| 916 | */ |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 917 | static int wt_status_check_worktree_changes(struct wt_status *s, |
| 918 | int *dirty_submodules) |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 919 | { |
| 920 | int i; |
| 921 | int changes = 0; |
| 922 | |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 923 | *dirty_submodules = 0; |
| 924 | |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 925 | for (i = 0; i < s->change.nr; i++) { |
| 926 | struct wt_status_change_data *d; |
| 927 | d = s->change.items[i].util; |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 928 | if (!d->worktree_status || |
| 929 | d->worktree_status == DIFF_STATUS_UNMERGED) |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 930 | continue; |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 931 | if (!changes) |
| 932 | changes = 1; |
| 933 | if (d->dirty_submodule) |
| 934 | *dirty_submodules = 1; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 935 | if (d->worktree_status == DIFF_STATUS_DELETED) |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 936 | changes = -1; |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 937 | } |
| 938 | return changes; |
| 939 | } |
| 940 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 941 | static void wt_longstatus_print_changed(struct wt_status *s) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 942 | { |
Jens Lehmann | 9297f77e6 | 2010-03-08 13:53:19 +0100 | [diff] [blame] | 943 | int i, dirty_submodules; |
| 944 | int worktree_changes = wt_status_check_worktree_changes(s, &dirty_submodules); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 945 | |
| 946 | if (!worktree_changes) |
| 947 | return; |
| 948 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 949 | wt_longstatus_print_dirty_header(s, worktree_changes < 0, dirty_submodules); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 950 | |
| 951 | for (i = 0; i < s->change.nr; i++) { |
| 952 | struct wt_status_change_data *d; |
| 953 | struct string_list_item *it; |
| 954 | it = &(s->change.items[i]); |
| 955 | d = it->util; |
Junio C Hamano | 4d4d572 | 2009-08-05 00:04:51 -0700 | [diff] [blame] | 956 | if (!d->worktree_status || |
| 957 | d->worktree_status == DIFF_STATUS_UNMERGED) |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 958 | continue; |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 959 | wt_longstatus_print_change_data(s, WT_STATUS_CHANGED, it); |
Junio C Hamano | 50b7e70 | 2009-08-04 23:49:33 -0700 | [diff] [blame] | 960 | } |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 961 | wt_longstatus_print_trailer(s); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 962 | } |
| 963 | |
Ævar Arnfjörð Bjarmason | 5cf88fd | 2022-08-25 19:09:48 +0200 | [diff] [blame] | 964 | static int stash_count_refs(struct object_id *ooid UNUSED, |
| 965 | struct object_id *noid UNUSED, |
| 966 | const char *email UNUSED, |
| 967 | timestamp_t timestamp UNUSED, int tz UNUSED, |
| 968 | const char *message UNUSED, void *cb_data) |
Liam Beguin | c1b5d01 | 2017-06-17 18:30:51 -0400 | [diff] [blame] | 969 | { |
| 970 | int *c = cb_data; |
| 971 | (*c)++; |
| 972 | return 0; |
| 973 | } |
| 974 | |
Øystein Walle | 612942a | 2021-10-22 00:25:31 +0200 | [diff] [blame] | 975 | static int count_stash_entries(void) |
| 976 | { |
| 977 | int n = 0; |
| 978 | for_each_reflog_ent("refs/stash", stash_count_refs, &n); |
| 979 | return n; |
| 980 | } |
| 981 | |
Liam Beguin | c1b5d01 | 2017-06-17 18:30:51 -0400 | [diff] [blame] | 982 | static void wt_longstatus_print_stash_summary(struct wt_status *s) |
| 983 | { |
Øystein Walle | 612942a | 2021-10-22 00:25:31 +0200 | [diff] [blame] | 984 | int stash_count = count_stash_entries(); |
Liam Beguin | c1b5d01 | 2017-06-17 18:30:51 -0400 | [diff] [blame] | 985 | |
Liam Beguin | c1b5d01 | 2017-06-17 18:30:51 -0400 | [diff] [blame] | 986 | if (stash_count > 0) |
| 987 | status_printf_ln(s, GIT_COLOR_NORMAL, |
| 988 | Q_("Your stash currently has %d entry", |
| 989 | "Your stash currently has %d entries", stash_count), |
| 990 | stash_count); |
| 991 | } |
| 992 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 993 | static void wt_longstatus_print_submodule_summary(struct wt_status *s, int uncommitted) |
Ping Yin | ac8d5af | 2008-04-12 23:05:32 +0800 | [diff] [blame] | 994 | { |
René Scharfe | d318027 | 2014-08-19 21:09:35 +0200 | [diff] [blame] | 995 | struct child_process sm_summary = CHILD_PROCESS_INIT; |
Matthieu Moy | 3ba7407 | 2013-09-06 19:43:06 +0200 | [diff] [blame] | 996 | struct strbuf cmd_stdout = STRBUF_INIT; |
| 997 | struct strbuf summary = STRBUF_INIT; |
| 998 | char *summary_content; |
Ping Yin | ac8d5af | 2008-04-12 23:05:32 +0800 | [diff] [blame] | 999 | |
Ævar Arnfjörð Bjarmason | 29fda24 | 2022-06-02 11:09:50 +0200 | [diff] [blame] | 1000 | strvec_pushf(&sm_summary.env, "GIT_INDEX_FILE=%s", s->index_file); |
Ping Yin | ac8d5af | 2008-04-12 23:05:32 +0800 | [diff] [blame] | 1001 | |
Jeff King | c972bf4 | 2020-07-28 16:25:12 -0400 | [diff] [blame] | 1002 | strvec_push(&sm_summary.args, "submodule"); |
| 1003 | strvec_push(&sm_summary.args, "summary"); |
| 1004 | strvec_push(&sm_summary.args, uncommitted ? "--files" : "--cached"); |
| 1005 | strvec_push(&sm_summary.args, "--for-status"); |
| 1006 | strvec_push(&sm_summary.args, "--summary-limit"); |
| 1007 | strvec_pushf(&sm_summary.args, "%d", s->submodule_summary); |
Matthieu Moy | bb7e32e | 2013-09-06 19:43:05 +0200 | [diff] [blame] | 1008 | if (!uncommitted) |
Jeff King | c972bf4 | 2020-07-28 16:25:12 -0400 | [diff] [blame] | 1009 | strvec_push(&sm_summary.args, s->amend ? "HEAD^" : "HEAD"); |
Matthieu Moy | bb7e32e | 2013-09-06 19:43:05 +0200 | [diff] [blame] | 1010 | |
Ping Yin | ac8d5af | 2008-04-12 23:05:32 +0800 | [diff] [blame] | 1011 | sm_summary.git_cmd = 1; |
| 1012 | sm_summary.no_stdin = 1; |
Matthieu Moy | 3ba7407 | 2013-09-06 19:43:06 +0200 | [diff] [blame] | 1013 | |
Jeff King | 5c950e9 | 2015-03-22 23:53:52 -0400 | [diff] [blame] | 1014 | capture_command(&sm_summary, &cmd_stdout, 1024); |
Matthieu Moy | 3ba7407 | 2013-09-06 19:43:06 +0200 | [diff] [blame] | 1015 | |
| 1016 | /* prepend header, only if there's an actual output */ |
Jeff King | d56d966 | 2015-03-22 06:00:32 -0400 | [diff] [blame] | 1017 | if (cmd_stdout.len) { |
Matthieu Moy | 3ba7407 | 2013-09-06 19:43:06 +0200 | [diff] [blame] | 1018 | if (uncommitted) |
| 1019 | strbuf_addstr(&summary, _("Submodules changed but not updated:")); |
| 1020 | else |
| 1021 | strbuf_addstr(&summary, _("Submodule changes to be committed:")); |
| 1022 | strbuf_addstr(&summary, "\n\n"); |
| 1023 | } |
| 1024 | strbuf_addbuf(&summary, &cmd_stdout); |
| 1025 | strbuf_release(&cmd_stdout); |
| 1026 | |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 1027 | if (s->display_comment_prefix) { |
Jeff King | d56d966 | 2015-03-22 06:00:32 -0400 | [diff] [blame] | 1028 | size_t len; |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 1029 | summary_content = strbuf_detach(&summary, &len); |
Calvin Wan | 787cb8a | 2023-06-06 19:48:43 +0000 | [diff] [blame] | 1030 | strbuf_add_commented_lines(&summary, summary_content, len, comment_line_char); |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 1031 | free(summary_content); |
| 1032 | } |
Matthieu Moy | 3ba7407 | 2013-09-06 19:43:06 +0200 | [diff] [blame] | 1033 | |
| 1034 | fputs(summary.buf, s->fp); |
| 1035 | strbuf_release(&summary); |
Ping Yin | ac8d5af | 2008-04-12 23:05:32 +0800 | [diff] [blame] | 1036 | } |
| 1037 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1038 | static void wt_longstatus_print_other(struct wt_status *s, |
| 1039 | struct string_list *l, |
| 1040 | const char *what, |
| 1041 | const char *how) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1042 | { |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1043 | int i; |
Brandon Casey | f285a2d | 2008-10-09 14:12:12 -0500 | [diff] [blame] | 1044 | struct strbuf buf = STRBUF_INIT; |
Nguyễn Thái Ngọc Duy | 323d053 | 2012-04-13 17:54:39 +0700 | [diff] [blame] | 1045 | static struct string_list output = STRING_LIST_INIT_DUP; |
| 1046 | struct column_options copts; |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1047 | |
Jeff King | 1282988 | 2011-06-02 01:54:49 -0400 | [diff] [blame] | 1048 | if (!l->nr) |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 1049 | return; |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1050 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1051 | wt_longstatus_print_other_header(s, what, how); |
Junio C Hamano | 1b908b6 | 2010-04-10 00:19:46 -0700 | [diff] [blame] | 1052 | |
| 1053 | for (i = 0; i < l->nr; i++) { |
Junio C Hamano | 7637868 | 2009-08-10 00:36:33 -0700 | [diff] [blame] | 1054 | struct string_list_item *it; |
Nguyễn Thái Ngọc Duy | 323d053 | 2012-04-13 17:54:39 +0700 | [diff] [blame] | 1055 | const char *path; |
Junio C Hamano | 1b908b6 | 2010-04-10 00:19:46 -0700 | [diff] [blame] | 1056 | it = &(l->items[i]); |
Junio C Hamano | 88910c9 | 2020-09-10 10:01:54 -0700 | [diff] [blame] | 1057 | path = quote_path(it->string, s->prefix, &buf, 0); |
Nguyễn Thái Ngọc Duy | 323d053 | 2012-04-13 17:54:39 +0700 | [diff] [blame] | 1058 | if (column_active(s->colopts)) { |
| 1059 | string_list_append(&output, path); |
| 1060 | continue; |
| 1061 | } |
Jonathan Nieder | b926c0d | 2011-02-25 23:11:37 -0600 | [diff] [blame] | 1062 | status_printf(s, color(WT_STATUS_HEADER, s), "\t"); |
| 1063 | status_printf_more(s, color(WT_STATUS_UNTRACKED, s), |
Nguyễn Thái Ngọc Duy | 323d053 | 2012-04-13 17:54:39 +0700 | [diff] [blame] | 1064 | "%s\n", path); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1065 | } |
Nguyễn Thái Ngọc Duy | 323d053 | 2012-04-13 17:54:39 +0700 | [diff] [blame] | 1066 | |
| 1067 | strbuf_release(&buf); |
| 1068 | if (!column_active(s->colopts)) |
Matthieu Moy | 2f0f7f1 | 2013-09-06 19:43:09 +0200 | [diff] [blame] | 1069 | goto conclude; |
Nguyễn Thái Ngọc Duy | 323d053 | 2012-04-13 17:54:39 +0700 | [diff] [blame] | 1070 | |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 1071 | strbuf_addf(&buf, "%s%s\t%s", |
Nguyễn Thái Ngọc Duy | 323d053 | 2012-04-13 17:54:39 +0700 | [diff] [blame] | 1072 | color(WT_STATUS_HEADER, s), |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 1073 | s->display_comment_prefix ? "#" : "", |
Nguyễn Thái Ngọc Duy | 323d053 | 2012-04-13 17:54:39 +0700 | [diff] [blame] | 1074 | color(WT_STATUS_UNTRACKED, s)); |
| 1075 | memset(&copts, 0, sizeof(copts)); |
| 1076 | copts.padding = 1; |
| 1077 | copts.indent = buf.buf; |
| 1078 | if (want_color(s->use_color)) |
| 1079 | copts.nl = GIT_COLOR_RESET "\n"; |
| 1080 | print_columns(&output, s->colopts, &copts); |
| 1081 | string_list_clear(&output, 0); |
Johannes Schindelin | 367c988 | 2007-11-11 17:35:41 +0000 | [diff] [blame] | 1082 | strbuf_release(&buf); |
Matthieu Moy | 2f0f7f1 | 2013-09-06 19:43:09 +0200 | [diff] [blame] | 1083 | conclude: |
Felipe Contreras | 7d7d680 | 2014-05-04 01:12:55 -0500 | [diff] [blame] | 1084 | status_printf_ln(s, GIT_COLOR_NORMAL, "%s", ""); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1085 | } |
| 1086 | |
Brian Malehorn | d76650b | 2017-05-15 23:06:49 -0700 | [diff] [blame] | 1087 | size_t wt_status_locate_end(const char *s, size_t len) |
Jens Lehmann | 1a72cfd | 2013-12-05 20:44:14 +0100 | [diff] [blame] | 1088 | { |
| 1089 | const char *p; |
| 1090 | struct strbuf pattern = STRBUF_INIT; |
| 1091 | |
SZEDER Gábor | fbfa097 | 2015-06-09 02:28:34 +0200 | [diff] [blame] | 1092 | strbuf_addf(&pattern, "\n%c %s", comment_line_char, cut_line); |
Brian Malehorn | d76650b | 2017-05-15 23:06:49 -0700 | [diff] [blame] | 1093 | if (starts_with(s, pattern.buf + 1)) |
| 1094 | len = 0; |
| 1095 | else if ((p = strstr(s, pattern.buf))) |
| 1096 | len = p - s + 1; |
Jens Lehmann | 1a72cfd | 2013-12-05 20:44:14 +0100 | [diff] [blame] | 1097 | strbuf_release(&pattern); |
Brian Malehorn | d76650b | 2017-05-15 23:06:49 -0700 | [diff] [blame] | 1098 | return len; |
Jens Lehmann | 1a72cfd | 2013-12-05 20:44:14 +0100 | [diff] [blame] | 1099 | } |
| 1100 | |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 1101 | void wt_status_append_cut_line(struct strbuf *buf) |
Nguyễn Thái Ngọc Duy | fcef931 | 2014-02-17 19:15:31 +0700 | [diff] [blame] | 1102 | { |
Kaartic Sivaraam | 8c4b1a3 | 2017-09-13 13:05:38 +0000 | [diff] [blame] | 1103 | const char *explanation = _("Do not modify or remove the line above.\nEverything below it will be ignored."); |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 1104 | |
Calvin Wan | 787cb8a | 2023-06-06 19:48:43 +0000 | [diff] [blame] | 1105 | strbuf_commented_addf(buf, comment_line_char, "%s", cut_line); |
| 1106 | strbuf_add_commented_lines(buf, explanation, strlen(explanation), comment_line_char); |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 1107 | } |
| 1108 | |
| 1109 | void wt_status_add_cut_line(FILE *fp) |
| 1110 | { |
Nguyễn Thái Ngọc Duy | fcef931 | 2014-02-17 19:15:31 +0700 | [diff] [blame] | 1111 | struct strbuf buf = STRBUF_INIT; |
| 1112 | |
Denton Liu | d540b70 | 2019-04-17 11:23:27 +0100 | [diff] [blame] | 1113 | wt_status_append_cut_line(&buf); |
Nguyễn Thái Ngọc Duy | fcef931 | 2014-02-17 19:15:31 +0700 | [diff] [blame] | 1114 | fputs(buf.buf, fp); |
| 1115 | strbuf_release(&buf); |
| 1116 | } |
| 1117 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1118 | static void wt_longstatus_print_verbose(struct wt_status *s) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1119 | { |
| 1120 | struct rev_info rev; |
Junio C Hamano | 32962c9 | 2010-03-08 22:58:09 -0800 | [diff] [blame] | 1121 | struct setup_revision_opt opt; |
Michael J Gruber | 4055500 | 2015-03-06 10:43:35 +0100 | [diff] [blame] | 1122 | int dirty_submodules; |
| 1123 | const char *c = color(WT_STATUS_HEADER, s); |
Kristian Høgsberg | 99a1269 | 2007-11-21 21:54:49 -0500 | [diff] [blame] | 1124 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 1125 | repo_init_revisions(s->repo, &rev, NULL); |
Brandon Williams | 0d1e0e7 | 2017-10-31 11:19:11 -0700 | [diff] [blame] | 1126 | rev.diffopt.flags.allow_textconv = 1; |
Nguyễn Thái Ngọc Duy | 425a28e | 2016-10-24 17:42:19 +0700 | [diff] [blame] | 1127 | rev.diffopt.ita_invisible_in_index = 1; |
Junio C Hamano | 32962c9 | 2010-03-08 22:58:09 -0800 | [diff] [blame] | 1128 | |
| 1129 | memset(&opt, 0, sizeof(opt)); |
brian m. carlson | f2e5119 | 2018-05-02 00:26:00 +0000 | [diff] [blame] | 1130 | opt.def = s->is_initial ? empty_tree_oid_hex() : s->reference; |
Junio C Hamano | 32962c9 | 2010-03-08 22:58:09 -0800 | [diff] [blame] | 1131 | setup_revisions(0, NULL, &rev, &opt); |
| 1132 | |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1133 | rev.diffopt.output_format |= DIFF_FORMAT_PATCH; |
Ben Peart | e8b2dc2 | 2018-05-11 15:38:58 +0000 | [diff] [blame] | 1134 | rev.diffopt.detect_rename = s->detect_rename >= 0 ? s->detect_rename : rev.diffopt.detect_rename; |
| 1135 | rev.diffopt.rename_limit = s->rename_limit >= 0 ? s->rename_limit : rev.diffopt.rename_limit; |
| 1136 | rev.diffopt.rename_score = s->rename_score >= 0 ? s->rename_score : rev.diffopt.rename_score; |
Kristian Høgsberg | 4ba0cb2 | 2008-03-10 13:58:26 -0400 | [diff] [blame] | 1137 | rev.diffopt.file = s->fp; |
| 1138 | rev.diffopt.close_file = 0; |
Jeff King | 4f672ad | 2008-10-26 00:49:35 -0400 | [diff] [blame] | 1139 | /* |
| 1140 | * If we're not going to stdout, then we definitely don't |
| 1141 | * want color, since we are going to the commit message |
| 1142 | * file (and even the "auto" setting won't work, since it |
Jens Lehmann | 1a72cfd | 2013-12-05 20:44:14 +0100 | [diff] [blame] | 1143 | * will have checked isatty on stdout). But we then do want |
| 1144 | * to insert the scissor line here to reliably remove the |
| 1145 | * diff before committing. |
Jeff King | 4f672ad | 2008-10-26 00:49:35 -0400 | [diff] [blame] | 1146 | */ |
Jens Lehmann | 1a72cfd | 2013-12-05 20:44:14 +0100 | [diff] [blame] | 1147 | if (s->fp != stdout) { |
Jeff King | f1c9626 | 2011-08-17 22:03:12 -0700 | [diff] [blame] | 1148 | rev.diffopt.use_color = 0; |
Nguyễn Thái Ngọc Duy | fcef931 | 2014-02-17 19:15:31 +0700 | [diff] [blame] | 1149 | wt_status_add_cut_line(s->fp); |
Jens Lehmann | 1a72cfd | 2013-12-05 20:44:14 +0100 | [diff] [blame] | 1150 | } |
Stephen P. Smith | 6fa9019 | 2018-09-05 17:53:27 -0700 | [diff] [blame] | 1151 | if (s->verbose > 1 && s->committable) { |
Michael J Gruber | 4055500 | 2015-03-06 10:43:35 +0100 | [diff] [blame] | 1152 | /* print_updated() printed a header, so do we */ |
| 1153 | if (s->fp != stdout) |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1154 | wt_longstatus_print_trailer(s); |
Michael J Gruber | 4055500 | 2015-03-06 10:43:35 +0100 | [diff] [blame] | 1155 | status_printf_ln(s, c, _("Changes to be committed:")); |
| 1156 | rev.diffopt.a_prefix = "c/"; |
| 1157 | rev.diffopt.b_prefix = "i/"; |
| 1158 | } /* else use prefix as per user config */ |
Junio C Hamano | 976b97e | 2023-08-21 16:14:14 -0400 | [diff] [blame] | 1159 | run_diff_index(&rev, DIFF_INDEX_CACHED); |
Michael J Gruber | 4055500 | 2015-03-06 10:43:35 +0100 | [diff] [blame] | 1160 | if (s->verbose > 1 && |
| 1161 | wt_status_check_worktree_changes(s, &dirty_submodules)) { |
| 1162 | status_printf_ln(s, c, |
| 1163 | "--------------------------------------------------"); |
| 1164 | status_printf_ln(s, c, _("Changes not staged for commit:")); |
| 1165 | setup_work_tree(); |
| 1166 | rev.diffopt.a_prefix = "i/"; |
| 1167 | rev.diffopt.b_prefix = "w/"; |
| 1168 | run_diff_files(&rev, 0); |
| 1169 | } |
Ævar Arnfjörð Bjarmason | 2108fe4 | 2022-04-13 22:01:36 +0200 | [diff] [blame] | 1170 | release_revisions(&rev); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1171 | } |
| 1172 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1173 | static void wt_longstatus_print_tracking(struct wt_status *s) |
Junio C Hamano | b6975ab | 2008-07-02 00:52:16 -0700 | [diff] [blame] | 1174 | { |
| 1175 | struct strbuf sb = STRBUF_INIT; |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 1176 | const char *cp, *ep, *branch_name; |
Junio C Hamano | b6975ab | 2008-07-02 00:52:16 -0700 | [diff] [blame] | 1177 | struct branch *branch; |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 1178 | char comment_line_string[3]; |
| 1179 | int i; |
Jeff Hostetler | 0a53561 | 2019-06-18 13:21:27 -0700 | [diff] [blame] | 1180 | uint64_t t_begin = 0; |
Junio C Hamano | b6975ab | 2008-07-02 00:52:16 -0700 | [diff] [blame] | 1181 | |
| 1182 | assert(s->branch && !s->is_initial); |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 1183 | if (!skip_prefix(s->branch, "refs/heads/", &branch_name)) |
Junio C Hamano | b6975ab | 2008-07-02 00:52:16 -0700 | [diff] [blame] | 1184 | return; |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 1185 | branch = branch_get(branch_name); |
Jeff Hostetler | 0a53561 | 2019-06-18 13:21:27 -0700 | [diff] [blame] | 1186 | |
| 1187 | t_begin = getnanotime(); |
| 1188 | |
Alex Henrie | b6f3da5 | 2023-07-12 22:41:13 -0600 | [diff] [blame] | 1189 | if (!format_tracking_info(branch, &sb, s->ahead_behind_flags, |
| 1190 | !s->commit_template)) |
Junio C Hamano | b6975ab | 2008-07-02 00:52:16 -0700 | [diff] [blame] | 1191 | return; |
| 1192 | |
Ben Boeckel | ed9bff0 | 2021-08-23 12:44:00 +0200 | [diff] [blame] | 1193 | if (advice_enabled(ADVICE_STATUS_AHEAD_BEHIND_WARNING) && |
Jeff Hostetler | 0a53561 | 2019-06-18 13:21:27 -0700 | [diff] [blame] | 1194 | s->ahead_behind_flags == AHEAD_BEHIND_FULL) { |
| 1195 | uint64_t t_delta_in_ms = (getnanotime() - t_begin) / 1000000; |
| 1196 | if (t_delta_in_ms > AB_DELAY_WARNING_IN_MS) { |
| 1197 | strbuf_addf(&sb, _("\n" |
| 1198 | "It took %.2f seconds to compute the branch ahead/behind values.\n" |
| 1199 | "You can use '--no-ahead-behind' to avoid this.\n"), |
| 1200 | t_delta_in_ms / 1000.0); |
| 1201 | } |
| 1202 | } |
| 1203 | |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 1204 | i = 0; |
| 1205 | if (s->display_comment_prefix) { |
| 1206 | comment_line_string[i++] = comment_line_char; |
| 1207 | comment_line_string[i++] = ' '; |
| 1208 | } |
| 1209 | comment_line_string[i] = '\0'; |
| 1210 | |
Junio C Hamano | b6975ab | 2008-07-02 00:52:16 -0700 | [diff] [blame] | 1211 | for (cp = sb.buf; (ep = strchr(cp, '\n')) != NULL; cp = ep + 1) |
Junio C Hamano | d249b09 | 2009-08-09 21:59:30 -0700 | [diff] [blame] | 1212 | color_fprintf_ln(s->fp, color(WT_STATUS_HEADER, s), |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 1213 | "%s%.*s", comment_line_string, |
Junio C Hamano | eff80a9 | 2013-01-16 20:18:48 +0100 | [diff] [blame] | 1214 | (int)(ep - cp), cp); |
Matthieu Moy | 2556b99 | 2013-09-06 19:43:07 +0200 | [diff] [blame] | 1215 | if (s->display_comment_prefix) |
| 1216 | color_fprintf_ln(s->fp, color(WT_STATUS_HEADER, s), "%c", |
| 1217 | comment_line_char); |
| 1218 | else |
Jeff King | 75177c8 | 2017-04-27 05:01:05 -0400 | [diff] [blame] | 1219 | fputs("\n", s->fp); |
Rene Scharfe | b6ec307 | 2017-08-30 20:20:18 +0200 | [diff] [blame] | 1220 | strbuf_release(&sb); |
Junio C Hamano | b6975ab | 2008-07-02 00:52:16 -0700 | [diff] [blame] | 1221 | } |
| 1222 | |
Rudy Rigot | ecbc23e | 2022-11-30 00:52:16 +0000 | [diff] [blame] | 1223 | static int uf_was_slow(struct wt_status *s) |
| 1224 | { |
| 1225 | if (getenv("GIT_TEST_UF_DELAY_WARNING")) |
| 1226 | s->untracked_in_ms = 3250; |
| 1227 | return UF_DELAY_WARNING_IN_MS < s->untracked_in_ms; |
| 1228 | } |
| 1229 | |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1230 | static void show_merge_in_progress(struct wt_status *s, |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1231 | const char *color) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1232 | { |
| 1233 | if (has_unmerged(s)) { |
| 1234 | status_printf_ln(s, color, _("You have unmerged paths.")); |
Matthieu Moy | b0a61ab | 2016-07-21 14:58:37 +0200 | [diff] [blame] | 1235 | if (s->hints) { |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1236 | status_printf_ln(s, color, |
Matthieu Moy | b0a61ab | 2016-07-21 14:58:37 +0200 | [diff] [blame] | 1237 | _(" (fix conflicts and run \"git commit\")")); |
| 1238 | status_printf_ln(s, color, |
| 1239 | _(" (use \"git merge --abort\" to abort the merge)")); |
| 1240 | } |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1241 | } else { |
| 1242 | status_printf_ln(s, color, |
| 1243 | _("All conflicts fixed but you are still merging.")); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1244 | if (s->hints) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1245 | status_printf_ln(s, color, |
| 1246 | _(" (use \"git commit\" to conclude merge)")); |
| 1247 | } |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1248 | wt_longstatus_print_trailer(s); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1249 | } |
| 1250 | |
| 1251 | static void show_am_in_progress(struct wt_status *s, |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1252 | const char *color) |
| 1253 | { |
徐沛文 (Aleen) | 9e7e41b | 2021-12-09 07:25:55 +0000 | [diff] [blame] | 1254 | int am_empty_patch; |
| 1255 | |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1256 | status_printf_ln(s, color, |
| 1257 | _("You are in the middle of an am session.")); |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1258 | if (s->state.am_empty_patch) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1259 | status_printf_ln(s, color, |
| 1260 | _("The current patch is empty.")); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1261 | if (s->hints) { |
徐沛文 (Aleen) | 9e7e41b | 2021-12-09 07:25:55 +0000 | [diff] [blame] | 1262 | am_empty_patch = s->state.am_empty_patch; |
| 1263 | if (!am_empty_patch) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1264 | status_printf_ln(s, color, |
Kevin Bracey | 8ceb6fb | 2013-06-26 23:06:41 +0300 | [diff] [blame] | 1265 | _(" (fix conflicts and then run \"git am --continue\")")); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1266 | status_printf_ln(s, color, |
| 1267 | _(" (use \"git am --skip\" to skip this patch)")); |
徐沛文 (Aleen) | 9e7e41b | 2021-12-09 07:25:55 +0000 | [diff] [blame] | 1268 | if (am_empty_patch) |
| 1269 | status_printf_ln(s, color, |
| 1270 | _(" (use \"git am --allow-empty\" to record this patch as an empty commit)")); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1271 | status_printf_ln(s, color, |
| 1272 | _(" (use \"git am --abort\" to restore the original branch)")); |
| 1273 | } |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1274 | wt_longstatus_print_trailer(s); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1275 | } |
| 1276 | |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1277 | static char *read_line_from_git_path(const char *filename) |
| 1278 | { |
| 1279 | struct strbuf buf = STRBUF_INIT; |
Nguyễn Thái Ngọc Duy | e9d983f | 2017-05-03 17:16:50 +0700 | [diff] [blame] | 1280 | FILE *fp = fopen_or_warn(git_path("%s", filename), "r"); |
| 1281 | |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1282 | if (!fp) { |
| 1283 | strbuf_release(&buf); |
| 1284 | return NULL; |
| 1285 | } |
Junio C Hamano | 8f309ae | 2016-01-13 15:31:17 -0800 | [diff] [blame] | 1286 | strbuf_getline_lf(&buf, fp); |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1287 | if (!fclose(fp)) { |
| 1288 | return strbuf_detach(&buf, NULL); |
| 1289 | } else { |
| 1290 | strbuf_release(&buf); |
| 1291 | return NULL; |
| 1292 | } |
| 1293 | } |
| 1294 | |
| 1295 | static int split_commit_in_progress(struct wt_status *s) |
| 1296 | { |
| 1297 | int split_in_progress = 0; |
Johannes Schindelin | 41fc6b3 | 2017-05-04 15:56:44 +0200 | [diff] [blame] | 1298 | char *head, *orig_head, *rebase_amend, *rebase_orig_head; |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1299 | |
Johannes Schindelin | 41fc6b3 | 2017-05-04 15:56:44 +0200 | [diff] [blame] | 1300 | if ((!s->amend && !s->nowarn && !s->workdir_dirty) || |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1301 | !s->branch || strcmp(s->branch, "HEAD")) |
Johannes Schindelin | 41fc6b3 | 2017-05-04 15:56:44 +0200 | [diff] [blame] | 1302 | return 0; |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1303 | |
Johannes Schindelin | 41fc6b3 | 2017-05-04 15:56:44 +0200 | [diff] [blame] | 1304 | head = read_line_from_git_path("HEAD"); |
| 1305 | orig_head = read_line_from_git_path("ORIG_HEAD"); |
| 1306 | rebase_amend = read_line_from_git_path("rebase-merge/amend"); |
| 1307 | rebase_orig_head = read_line_from_git_path("rebase-merge/orig-head"); |
| 1308 | |
| 1309 | if (!head || !orig_head || !rebase_amend || !rebase_orig_head) |
| 1310 | ; /* fall through, no split in progress */ |
| 1311 | else if (!strcmp(rebase_amend, rebase_orig_head)) |
| 1312 | split_in_progress = !!strcmp(head, rebase_amend); |
| 1313 | else if (strcmp(orig_head, rebase_orig_head)) |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1314 | split_in_progress = 1; |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1315 | |
| 1316 | free(head); |
| 1317 | free(orig_head); |
| 1318 | free(rebase_amend); |
| 1319 | free(rebase_orig_head); |
Johannes Schindelin | 41fc6b3 | 2017-05-04 15:56:44 +0200 | [diff] [blame] | 1320 | |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1321 | return split_in_progress; |
| 1322 | } |
| 1323 | |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1324 | /* |
| 1325 | * Turn |
| 1326 | * "pick d6a2f0303e897ec257dd0e0a39a5ccb709bc2047 some message" |
| 1327 | * into |
| 1328 | * "pick d6a2f03 some message" |
| 1329 | * |
| 1330 | * The function assumes that the line does not contain useless spaces |
| 1331 | * before or after the command. |
| 1332 | */ |
Martin Ågren | b1f1ade | 2020-09-27 15:15:41 +0200 | [diff] [blame] | 1333 | static void abbrev_oid_in_line(struct strbuf *line) |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1334 | { |
| 1335 | struct strbuf **split; |
| 1336 | int i; |
| 1337 | |
| 1338 | if (starts_with(line->buf, "exec ") || |
Johannes Schindelin | 225a777 | 2019-05-10 13:23:14 -0700 | [diff] [blame] | 1339 | starts_with(line->buf, "x ") || |
| 1340 | starts_with(line->buf, "label ") || |
| 1341 | starts_with(line->buf, "l ")) |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1342 | return; |
| 1343 | |
| 1344 | split = strbuf_split_max(line, ' ', 3); |
| 1345 | if (split[0] && split[1]) { |
brian m. carlson | e86ab2c | 2017-02-21 23:47:37 +0000 | [diff] [blame] | 1346 | struct object_id oid; |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1347 | |
| 1348 | /* |
| 1349 | * strbuf_split_max left a space. Trim it and re-add |
| 1350 | * it after abbreviation. |
| 1351 | */ |
| 1352 | strbuf_trim(split[1]); |
Ævar Arnfjörð Bjarmason | d850b7a | 2023-03-28 15:58:46 +0200 | [diff] [blame] | 1353 | if (!repo_get_oid(the_repository, split[1]->buf, &oid)) { |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1354 | strbuf_reset(split[1]); |
brian m. carlson | 30e677e | 2018-03-12 02:27:28 +0000 | [diff] [blame] | 1355 | strbuf_add_unique_abbrev(split[1], &oid, |
René Scharfe | a94bb68 | 2016-10-08 17:38:47 +0200 | [diff] [blame] | 1356 | DEFAULT_ABBREV); |
| 1357 | strbuf_addch(split[1], ' '); |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1358 | strbuf_reset(line); |
| 1359 | for (i = 0; split[i]; i++) |
René Scharfe | 8109984 | 2016-07-19 20:36:29 +0200 | [diff] [blame] | 1360 | strbuf_addbuf(line, split[i]); |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1361 | } |
| 1362 | } |
Stefan Beller | 6eb6078 | 2016-03-31 17:35:44 -0700 | [diff] [blame] | 1363 | strbuf_list_free(split); |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1364 | } |
| 1365 | |
Johannes Schindelin | df9ded4 | 2017-01-26 17:08:41 +0100 | [diff] [blame] | 1366 | static int read_rebase_todolist(const char *fname, struct string_list *lines) |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1367 | { |
| 1368 | struct strbuf line = STRBUF_INIT; |
| 1369 | FILE *f = fopen(git_path("%s", fname), "r"); |
| 1370 | |
Johannes Schindelin | df9ded4 | 2017-01-26 17:08:41 +0100 | [diff] [blame] | 1371 | if (!f) { |
| 1372 | if (errno == ENOENT) |
| 1373 | return -1; |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1374 | die_errno("Could not open file %s for reading", |
| 1375 | git_path("%s", fname)); |
Johannes Schindelin | df9ded4 | 2017-01-26 17:08:41 +0100 | [diff] [blame] | 1376 | } |
Junio C Hamano | 8f309ae | 2016-01-13 15:31:17 -0800 | [diff] [blame] | 1377 | while (!strbuf_getline_lf(&line, f)) { |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1378 | if (line.len && line.buf[0] == comment_line_char) |
| 1379 | continue; |
| 1380 | strbuf_trim(&line); |
| 1381 | if (!line.len) |
| 1382 | continue; |
Martin Ågren | b1f1ade | 2020-09-27 15:15:41 +0200 | [diff] [blame] | 1383 | abbrev_oid_in_line(&line); |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1384 | string_list_append(lines, line.buf); |
| 1385 | } |
Johannes Schindelin | e7b65e2 | 2017-05-04 15:55:52 +0200 | [diff] [blame] | 1386 | fclose(f); |
Rene Scharfe | 6f49541 | 2017-08-30 20:20:17 +0200 | [diff] [blame] | 1387 | strbuf_release(&line); |
Johannes Schindelin | df9ded4 | 2017-01-26 17:08:41 +0100 | [diff] [blame] | 1388 | return 0; |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1389 | } |
| 1390 | |
| 1391 | static void show_rebase_information(struct wt_status *s, |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1392 | const char *color) |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1393 | { |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1394 | if (s->state.rebase_interactive_in_progress) { |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1395 | int i; |
| 1396 | int nr_lines_to_show = 2; |
| 1397 | |
| 1398 | struct string_list have_done = STRING_LIST_INIT_DUP; |
| 1399 | struct string_list yet_to_do = STRING_LIST_INIT_DUP; |
| 1400 | |
| 1401 | read_rebase_todolist("rebase-merge/done", &have_done); |
Johannes Schindelin | df9ded4 | 2017-01-26 17:08:41 +0100 | [diff] [blame] | 1402 | if (read_rebase_todolist("rebase-merge/git-rebase-todo", |
| 1403 | &yet_to_do)) |
| 1404 | status_printf_ln(s, color, |
| 1405 | _("git-rebase-todo is missing.")); |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1406 | if (have_done.nr == 0) |
| 1407 | status_printf_ln(s, color, _("No commands done.")); |
| 1408 | else { |
| 1409 | status_printf_ln(s, color, |
Ævar Arnfjörð Bjarmason | 99d6054 | 2022-03-07 16:27:08 +0100 | [diff] [blame] | 1410 | Q_("Last command done (%"PRIuMAX" command done):", |
| 1411 | "Last commands done (%"PRIuMAX" commands done):", |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1412 | have_done.nr), |
Ævar Arnfjörð Bjarmason | 99d6054 | 2022-03-07 16:27:08 +0100 | [diff] [blame] | 1413 | (uintmax_t)have_done.nr); |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1414 | for (i = (have_done.nr > nr_lines_to_show) |
| 1415 | ? have_done.nr - nr_lines_to_show : 0; |
| 1416 | i < have_done.nr; |
| 1417 | i++) |
| 1418 | status_printf_ln(s, color, " %s", have_done.items[i].string); |
| 1419 | if (have_done.nr > nr_lines_to_show && s->hints) |
| 1420 | status_printf_ln(s, color, |
| 1421 | _(" (see more in file %s)"), git_path("rebase-merge/done")); |
| 1422 | } |
| 1423 | |
| 1424 | if (yet_to_do.nr == 0) |
| 1425 | status_printf_ln(s, color, |
| 1426 | _("No commands remaining.")); |
| 1427 | else { |
| 1428 | status_printf_ln(s, color, |
Ævar Arnfjörð Bjarmason | 99d6054 | 2022-03-07 16:27:08 +0100 | [diff] [blame] | 1429 | Q_("Next command to do (%"PRIuMAX" remaining command):", |
| 1430 | "Next commands to do (%"PRIuMAX" remaining commands):", |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1431 | yet_to_do.nr), |
Ævar Arnfjörð Bjarmason | 99d6054 | 2022-03-07 16:27:08 +0100 | [diff] [blame] | 1432 | (uintmax_t)yet_to_do.nr); |
Guillaume Pagès | 84e6fb9 | 2015-07-06 22:56:03 +0200 | [diff] [blame] | 1433 | for (i = 0; i < nr_lines_to_show && i < yet_to_do.nr; i++) |
| 1434 | status_printf_ln(s, color, " %s", yet_to_do.items[i].string); |
| 1435 | if (s->hints) |
| 1436 | status_printf_ln(s, color, |
| 1437 | _(" (use \"git rebase --edit-todo\" to view and edit)")); |
| 1438 | } |
| 1439 | string_list_clear(&yet_to_do, 0); |
| 1440 | string_list_clear(&have_done, 0); |
| 1441 | } |
| 1442 | } |
| 1443 | |
Guillaume Pagès | 05eb563 | 2015-06-30 15:01:12 +0200 | [diff] [blame] | 1444 | static void print_rebase_state(struct wt_status *s, |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1445 | const char *color) |
Guillaume Pagès | 05eb563 | 2015-06-30 15:01:12 +0200 | [diff] [blame] | 1446 | { |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1447 | if (s->state.branch) |
Guillaume Pagès | 05eb563 | 2015-06-30 15:01:12 +0200 | [diff] [blame] | 1448 | status_printf_ln(s, color, |
| 1449 | _("You are currently rebasing branch '%s' on '%s'."), |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1450 | s->state.branch, |
| 1451 | s->state.onto); |
Guillaume Pagès | 05eb563 | 2015-06-30 15:01:12 +0200 | [diff] [blame] | 1452 | else |
| 1453 | status_printf_ln(s, color, |
| 1454 | _("You are currently rebasing.")); |
| 1455 | } |
| 1456 | |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1457 | static void show_rebase_in_progress(struct wt_status *s, |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1458 | const char *color) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1459 | { |
| 1460 | struct stat st; |
| 1461 | |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1462 | show_rebase_information(s, color); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1463 | if (has_unmerged(s)) { |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1464 | print_rebase_state(s, color); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1465 | if (s->hints) { |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1466 | status_printf_ln(s, color, |
| 1467 | _(" (fix conflicts and then run \"git rebase --continue\")")); |
| 1468 | status_printf_ln(s, color, |
| 1469 | _(" (use \"git rebase --skip\" to skip this patch)")); |
| 1470 | status_printf_ln(s, color, |
| 1471 | _(" (use \"git rebase --abort\" to check out the original branch)")); |
| 1472 | } |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1473 | } else if (s->state.rebase_in_progress || |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 1474 | !stat(git_path_merge_msg(s->repo), &st)) { |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1475 | print_rebase_state(s, color); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1476 | if (s->hints) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1477 | status_printf_ln(s, color, |
| 1478 | _(" (all conflicts fixed: run \"git rebase --continue\")")); |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1479 | } else if (split_commit_in_progress(s)) { |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1480 | if (s->state.branch) |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1481 | status_printf_ln(s, color, |
| 1482 | _("You are currently splitting a commit while rebasing branch '%s' on '%s'."), |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1483 | s->state.branch, |
| 1484 | s->state.onto); |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1485 | else |
| 1486 | status_printf_ln(s, color, |
| 1487 | _("You are currently splitting a commit during a rebase.")); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1488 | if (s->hints) |
Lucien Kong | 2d1cceb | 2012-06-10 13:17:38 +0200 | [diff] [blame] | 1489 | status_printf_ln(s, color, |
| 1490 | _(" (Once your working directory is clean, run \"git rebase --continue\")")); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1491 | } else { |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1492 | if (s->state.branch) |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1493 | status_printf_ln(s, color, |
| 1494 | _("You are currently editing a commit while rebasing branch '%s' on '%s'."), |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1495 | s->state.branch, |
| 1496 | s->state.onto); |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1497 | else |
| 1498 | status_printf_ln(s, color, |
| 1499 | _("You are currently editing a commit during a rebase.")); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1500 | if (s->hints && !s->amend) { |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1501 | status_printf_ln(s, color, |
| 1502 | _(" (use \"git commit --amend\" to amend the current commit)")); |
| 1503 | status_printf_ln(s, color, |
| 1504 | _(" (use \"git rebase --continue\" once you are satisfied with your changes)")); |
| 1505 | } |
| 1506 | } |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1507 | wt_longstatus_print_trailer(s); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1508 | } |
| 1509 | |
| 1510 | static void show_cherry_pick_in_progress(struct wt_status *s, |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1511 | const char *color) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1512 | { |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1513 | if (is_null_oid(&s->state.cherry_pick_head_oid)) |
| 1514 | status_printf_ln(s, color, |
| 1515 | _("Cherry-pick currently in progress.")); |
| 1516 | else |
| 1517 | status_printf_ln(s, color, |
| 1518 | _("You are currently cherry-picking commit %s."), |
Ævar Arnfjörð Bjarmason | d850b7a | 2023-03-28 15:58:46 +0200 | [diff] [blame] | 1519 | repo_find_unique_abbrev(the_repository, &s->state.cherry_pick_head_oid, |
| 1520 | DEFAULT_ABBREV)); |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1521 | |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1522 | if (s->hints) { |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1523 | if (has_unmerged(s)) |
| 1524 | status_printf_ln(s, color, |
Ralf Thielow | b95e66f | 2013-06-17 06:28:26 +0200 | [diff] [blame] | 1525 | _(" (fix conflicts and run \"git cherry-pick --continue\")")); |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1526 | else if (is_null_oid(&s->state.cherry_pick_head_oid)) |
| 1527 | status_printf_ln(s, color, |
| 1528 | _(" (run \"git cherry-pick --continue\" to continue)")); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1529 | else |
| 1530 | status_printf_ln(s, color, |
Ralf Thielow | b95e66f | 2013-06-17 06:28:26 +0200 | [diff] [blame] | 1531 | _(" (all conflicts fixed: run \"git cherry-pick --continue\")")); |
| 1532 | status_printf_ln(s, color, |
Denton Liu | 86ae43d | 2019-08-27 00:45:41 -0400 | [diff] [blame] | 1533 | _(" (use \"git cherry-pick --skip\" to skip this patch)")); |
| 1534 | status_printf_ln(s, color, |
Ralf Thielow | b95e66f | 2013-06-17 06:28:26 +0200 | [diff] [blame] | 1535 | _(" (use \"git cherry-pick --abort\" to cancel the cherry-pick operation)")); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1536 | } |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1537 | wt_longstatus_print_trailer(s); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1538 | } |
| 1539 | |
Matthieu Moy | db4ef44 | 2013-04-02 16:20:21 +0200 | [diff] [blame] | 1540 | static void show_revert_in_progress(struct wt_status *s, |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1541 | const char *color) |
Matthieu Moy | db4ef44 | 2013-04-02 16:20:21 +0200 | [diff] [blame] | 1542 | { |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1543 | if (is_null_oid(&s->state.revert_head_oid)) |
| 1544 | status_printf_ln(s, color, |
| 1545 | _("Revert currently in progress.")); |
| 1546 | else |
| 1547 | status_printf_ln(s, color, |
| 1548 | _("You are currently reverting commit %s."), |
Ævar Arnfjörð Bjarmason | d850b7a | 2023-03-28 15:58:46 +0200 | [diff] [blame] | 1549 | repo_find_unique_abbrev(the_repository, &s->state.revert_head_oid, |
| 1550 | DEFAULT_ABBREV)); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1551 | if (s->hints) { |
Matthieu Moy | db4ef44 | 2013-04-02 16:20:21 +0200 | [diff] [blame] | 1552 | if (has_unmerged(s)) |
| 1553 | status_printf_ln(s, color, |
| 1554 | _(" (fix conflicts and run \"git revert --continue\")")); |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1555 | else if (is_null_oid(&s->state.revert_head_oid)) |
| 1556 | status_printf_ln(s, color, |
| 1557 | _(" (run \"git revert --continue\" to continue)")); |
Matthieu Moy | db4ef44 | 2013-04-02 16:20:21 +0200 | [diff] [blame] | 1558 | else |
| 1559 | status_printf_ln(s, color, |
| 1560 | _(" (all conflicts fixed: run \"git revert --continue\")")); |
| 1561 | status_printf_ln(s, color, |
Denton Liu | 86ae43d | 2019-08-27 00:45:41 -0400 | [diff] [blame] | 1562 | _(" (use \"git revert --skip\" to skip this patch)")); |
| 1563 | status_printf_ln(s, color, |
Matthieu Moy | db4ef44 | 2013-04-02 16:20:21 +0200 | [diff] [blame] | 1564 | _(" (use \"git revert --abort\" to cancel the revert operation)")); |
| 1565 | } |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1566 | wt_longstatus_print_trailer(s); |
Matthieu Moy | db4ef44 | 2013-04-02 16:20:21 +0200 | [diff] [blame] | 1567 | } |
| 1568 | |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1569 | static void show_bisect_in_progress(struct wt_status *s, |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1570 | const char *color) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1571 | { |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1572 | if (s->state.branch) |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1573 | status_printf_ln(s, color, |
Nguyễn Thái Ngọc Duy | 6deab24 | 2013-03-23 10:52:44 +0700 | [diff] [blame] | 1574 | _("You are currently bisecting, started from branch '%s'."), |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1575 | s->state.branch); |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1576 | else |
| 1577 | status_printf_ln(s, color, |
| 1578 | _("You are currently bisecting.")); |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1579 | if (s->hints) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1580 | status_printf_ln(s, color, |
| 1581 | _(" (use \"git bisect reset\" to get back to the original branch)")); |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1582 | wt_longstatus_print_trailer(s); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1583 | } |
| 1584 | |
Elijah Newren | 051df3c | 2020-06-18 20:49:57 +0000 | [diff] [blame] | 1585 | static void show_sparse_checkout_in_use(struct wt_status *s, |
| 1586 | const char *color) |
| 1587 | { |
| 1588 | if (s->state.sparse_checkout_percentage == SPARSE_CHECKOUT_DISABLED) |
| 1589 | return; |
| 1590 | |
Derrick Stolee | bf48e5a | 2021-07-14 13:12:36 +0000 | [diff] [blame] | 1591 | if (s->state.sparse_checkout_percentage == SPARSE_CHECKOUT_SPARSE_INDEX) |
| 1592 | status_printf_ln(s, color, _("You are in a sparse checkout.")); |
| 1593 | else |
| 1594 | status_printf_ln(s, color, |
| 1595 | _("You are in a sparse checkout with %d%% of tracked files present."), |
| 1596 | s->state.sparse_checkout_percentage); |
Elijah Newren | 051df3c | 2020-06-18 20:49:57 +0000 | [diff] [blame] | 1597 | wt_longstatus_print_trailer(s); |
| 1598 | } |
| 1599 | |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1600 | /* |
| 1601 | * Extract branch information from rebase/bisect |
| 1602 | */ |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 1603 | static char *get_branch(const struct worktree *wt, const char *path) |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1604 | { |
Nguyễn Thái Ngọc Duy | 8b87cfd | 2013-03-16 09:12:36 +0700 | [diff] [blame] | 1605 | struct strbuf sb = STRBUF_INIT; |
brian m. carlson | e86ab2c | 2017-02-21 23:47:37 +0000 | [diff] [blame] | 1606 | struct object_id oid; |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 1607 | const char *branch_name; |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1608 | |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 1609 | if (strbuf_read_file(&sb, worktree_git_path(wt, "%s", path), 0) <= 0) |
Nguyễn Thái Ngọc Duy | 8b87cfd | 2013-03-16 09:12:36 +0700 | [diff] [blame] | 1610 | goto got_nothing; |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1611 | |
Jeff King | 66ec904 | 2015-01-28 12:57:35 -0500 | [diff] [blame] | 1612 | while (sb.len && sb.buf[sb.len - 1] == '\n') |
Nguyễn Thái Ngọc Duy | 8b87cfd | 2013-03-16 09:12:36 +0700 | [diff] [blame] | 1613 | strbuf_setlen(&sb, sb.len - 1); |
| 1614 | if (!sb.len) |
| 1615 | goto got_nothing; |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 1616 | if (skip_prefix(sb.buf, "refs/heads/", &branch_name)) |
| 1617 | strbuf_remove(&sb, 0, branch_name - sb.buf); |
Christian Couder | 5955654 | 2013-11-30 21:55:40 +0100 | [diff] [blame] | 1618 | else if (starts_with(sb.buf, "refs/")) |
Nguyễn Thái Ngọc Duy | 8b87cfd | 2013-03-16 09:12:36 +0700 | [diff] [blame] | 1619 | ; |
brian m. carlson | e86ab2c | 2017-02-21 23:47:37 +0000 | [diff] [blame] | 1620 | else if (!get_oid_hex(sb.buf, &oid)) { |
Nguyễn Thái Ngọc Duy | 8b87cfd | 2013-03-16 09:12:36 +0700 | [diff] [blame] | 1621 | strbuf_reset(&sb); |
brian m. carlson | 30e677e | 2018-03-12 02:27:28 +0000 | [diff] [blame] | 1622 | strbuf_add_unique_abbrev(&sb, &oid, DEFAULT_ABBREV); |
Nguyễn Thái Ngọc Duy | 8b87cfd | 2013-03-16 09:12:36 +0700 | [diff] [blame] | 1623 | } else if (!strcmp(sb.buf, "detached HEAD")) /* rebase */ |
| 1624 | goto got_nothing; |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1625 | else /* bisect */ |
Nguyễn Thái Ngọc Duy | 8b87cfd | 2013-03-16 09:12:36 +0700 | [diff] [blame] | 1626 | ; |
| 1627 | return strbuf_detach(&sb, NULL); |
| 1628 | |
| 1629 | got_nothing: |
| 1630 | strbuf_release(&sb); |
| 1631 | return NULL; |
Nguyễn Thái Ngọc Duy | 0722c80 | 2013-02-03 12:53:27 +0700 | [diff] [blame] | 1632 | } |
| 1633 | |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1634 | struct grab_1st_switch_cbdata { |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1635 | struct strbuf buf; |
brian m. carlson | e86ab2c | 2017-02-21 23:47:37 +0000 | [diff] [blame] | 1636 | struct object_id noid; |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1637 | }; |
| 1638 | |
Ævar Arnfjörð Bjarmason | 5cf88fd | 2022-08-25 19:09:48 +0200 | [diff] [blame] | 1639 | static int grab_1st_switch(struct object_id *ooid UNUSED, |
Jeff King | c006e9f | 2022-08-19 06:08:35 -0400 | [diff] [blame] | 1640 | struct object_id *noid, |
Ævar Arnfjörð Bjarmason | 5cf88fd | 2022-08-25 19:09:48 +0200 | [diff] [blame] | 1641 | const char *email UNUSED, |
| 1642 | timestamp_t timestamp UNUSED, int tz UNUSED, |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1643 | const char *message, void *cb_data) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1644 | { |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1645 | struct grab_1st_switch_cbdata *cb = cb_data; |
| 1646 | const char *target = NULL, *end; |
| 1647 | |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 1648 | if (!skip_prefix(message, "checkout: moving from ", &message)) |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1649 | return 0; |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1650 | target = strstr(message, " to "); |
| 1651 | if (!target) |
| 1652 | return 0; |
| 1653 | target += strlen(" to "); |
| 1654 | strbuf_reset(&cb->buf); |
brian m. carlson | e86ab2c | 2017-02-21 23:47:37 +0000 | [diff] [blame] | 1655 | oidcpy(&cb->noid, noid); |
René Scharfe | 904de44 | 2015-11-25 15:10:18 +0100 | [diff] [blame] | 1656 | end = strchrnul(target, '\n'); |
| 1657 | strbuf_add(&cb->buf, target, end - target); |
| 1658 | if (!strcmp(cb->buf.buf, "HEAD")) { |
Matthieu Moy | 0eb8548 | 2015-09-27 17:13:42 +0200 | [diff] [blame] | 1659 | /* HEAD is relative. Resolve it to the right reflog entry. */ |
René Scharfe | 904de44 | 2015-11-25 15:10:18 +0100 | [diff] [blame] | 1660 | strbuf_reset(&cb->buf); |
brian m. carlson | 30e677e | 2018-03-12 02:27:28 +0000 | [diff] [blame] | 1661 | strbuf_add_unique_abbrev(&cb->buf, noid, DEFAULT_ABBREV); |
Matthieu Moy | 0eb8548 | 2015-09-27 17:13:42 +0200 | [diff] [blame] | 1662 | } |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1663 | return 1; |
| 1664 | } |
| 1665 | |
Nguyễn Thái Ngọc Duy | 7884545 | 2018-11-10 06:48:50 +0100 | [diff] [blame] | 1666 | static void wt_status_get_detached_from(struct repository *r, |
| 1667 | struct wt_status_state *state) |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1668 | { |
| 1669 | struct grab_1st_switch_cbdata cb; |
| 1670 | struct commit *commit; |
brian m. carlson | e86ab2c | 2017-02-21 23:47:37 +0000 | [diff] [blame] | 1671 | struct object_id oid; |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1672 | char *ref = NULL; |
| 1673 | |
| 1674 | strbuf_init(&cb.buf, 0); |
| 1675 | if (for_each_reflog_ent_reverse("HEAD", grab_1st_switch, &cb) <= 0) { |
| 1676 | strbuf_release(&cb.buf); |
| 1677 | return; |
| 1678 | } |
| 1679 | |
Ævar Arnfjörð Bjarmason | 4a93b89 | 2023-03-28 15:58:58 +0200 | [diff] [blame] | 1680 | if (repo_dwim_ref(r, cb.buf.buf, cb.buf.len, &oid, &ref, |
Ævar Arnfjörð Bjarmason | 12cb1c1 | 2023-03-28 15:58:54 +0200 | [diff] [blame] | 1681 | 1) == 1 && |
Martin Ågren | b1f1ade | 2020-09-27 15:15:41 +0200 | [diff] [blame] | 1682 | /* oid is a commit? match without further lookup */ |
Jeff King | 4a7e27e | 2018-08-28 17:22:40 -0400 | [diff] [blame] | 1683 | (oideq(&cb.noid, &oid) || |
Martin Ågren | b1f1ade | 2020-09-27 15:15:41 +0200 | [diff] [blame] | 1684 | /* perhaps oid is a tag, try to dereference to a commit */ |
Nguyễn Thái Ngọc Duy | 7884545 | 2018-11-10 06:48:50 +0100 | [diff] [blame] | 1685 | ((commit = lookup_commit_reference_gently(r, &oid, 1)) != NULL && |
Jeff King | 4a7e27e | 2018-08-28 17:22:40 -0400 | [diff] [blame] | 1686 | oideq(&cb.noid, &commit->object.oid)))) { |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 1687 | const char *from = ref; |
| 1688 | if (!skip_prefix(from, "refs/tags/", &from)) |
| 1689 | skip_prefix(from, "refs/remotes/", &from); |
| 1690 | state->detached_from = xstrdup(from); |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1691 | } else |
| 1692 | state->detached_from = |
Ævar Arnfjörð Bjarmason | 4a93b89 | 2023-03-28 15:58:58 +0200 | [diff] [blame] | 1693 | xstrdup(repo_find_unique_abbrev(r, &cb.noid, DEFAULT_ABBREV)); |
brian m. carlson | 40f5555 | 2018-03-12 02:27:29 +0000 | [diff] [blame] | 1694 | oidcpy(&state->detached_oid, &cb.noid); |
Ævar Arnfjörð Bjarmason | 4a93b89 | 2023-03-28 15:58:58 +0200 | [diff] [blame] | 1695 | state->detached_at = !repo_get_oid(r, "HEAD", &oid) && |
Jeff King | 4a7e27e | 2018-08-28 17:22:40 -0400 | [diff] [blame] | 1696 | oideq(&oid, &state->detached_oid); |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1697 | |
| 1698 | free(ref); |
| 1699 | strbuf_release(&cb.buf); |
| 1700 | } |
| 1701 | |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 1702 | int wt_status_check_rebase(const struct worktree *wt, |
| 1703 | struct wt_status_state *state) |
Nguyễn Thái Ngọc Duy | b9691db | 2013-03-13 18:42:50 +0700 | [diff] [blame] | 1704 | { |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1705 | struct stat st; |
| 1706 | |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 1707 | if (!stat(worktree_git_path(wt, "rebase-apply"), &st)) { |
| 1708 | if (!stat(worktree_git_path(wt, "rebase-apply/applying"), &st)) { |
Nguyễn Thái Ngọc Duy | b9691db | 2013-03-13 18:42:50 +0700 | [diff] [blame] | 1709 | state->am_in_progress = 1; |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 1710 | if (!stat(worktree_git_path(wt, "rebase-apply/patch"), &st) && !st.st_size) |
Nguyễn Thái Ngọc Duy | b9691db | 2013-03-13 18:42:50 +0700 | [diff] [blame] | 1711 | state->am_empty_patch = 1; |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1712 | } else { |
Nguyễn Thái Ngọc Duy | b9691db | 2013-03-13 18:42:50 +0700 | [diff] [blame] | 1713 | state->rebase_in_progress = 1; |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 1714 | state->branch = get_branch(wt, "rebase-apply/head-name"); |
| 1715 | state->onto = get_branch(wt, "rebase-apply/onto"); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1716 | } |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 1717 | } else if (!stat(worktree_git_path(wt, "rebase-merge"), &st)) { |
| 1718 | if (!stat(worktree_git_path(wt, "rebase-merge/interactive"), &st)) |
Nguyễn Thái Ngọc Duy | b9691db | 2013-03-13 18:42:50 +0700 | [diff] [blame] | 1719 | state->rebase_interactive_in_progress = 1; |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1720 | else |
Nguyễn Thái Ngọc Duy | b9691db | 2013-03-13 18:42:50 +0700 | [diff] [blame] | 1721 | state->rebase_in_progress = 1; |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 1722 | state->branch = get_branch(wt, "rebase-merge/head-name"); |
| 1723 | state->onto = get_branch(wt, "rebase-merge/onto"); |
Nguyễn Thái Ngọc Duy | bcd522a | 2016-04-22 20:01:30 +0700 | [diff] [blame] | 1724 | } else |
| 1725 | return 0; |
| 1726 | return 1; |
| 1727 | } |
| 1728 | |
Nguyễn Thái Ngọc Duy | f5d067a | 2016-04-22 20:01:34 +0700 | [diff] [blame] | 1729 | int wt_status_check_bisect(const struct worktree *wt, |
| 1730 | struct wt_status_state *state) |
| 1731 | { |
| 1732 | struct stat st; |
| 1733 | |
| 1734 | if (!stat(worktree_git_path(wt, "BISECT_LOG"), &st)) { |
| 1735 | state->bisect_in_progress = 1; |
| 1736 | state->branch = get_branch(wt, "BISECT_START"); |
| 1737 | return 1; |
| 1738 | } |
| 1739 | return 0; |
| 1740 | } |
| 1741 | |
Elijah Newren | 051df3c | 2020-06-18 20:49:57 +0000 | [diff] [blame] | 1742 | static void wt_status_check_sparse_checkout(struct repository *r, |
| 1743 | struct wt_status_state *state) |
| 1744 | { |
| 1745 | int skip_worktree = 0; |
| 1746 | int i; |
| 1747 | |
| 1748 | if (!core_apply_sparse_checkout || r->index->cache_nr == 0) { |
| 1749 | /* |
| 1750 | * Don't compute percentage of checked out files if we |
| 1751 | * aren't in a sparse checkout or would get division by 0. |
| 1752 | */ |
| 1753 | state->sparse_checkout_percentage = SPARSE_CHECKOUT_DISABLED; |
| 1754 | return; |
| 1755 | } |
| 1756 | |
Derrick Stolee | bf48e5a | 2021-07-14 13:12:36 +0000 | [diff] [blame] | 1757 | if (r->index->sparse_index) { |
| 1758 | state->sparse_checkout_percentage = SPARSE_CHECKOUT_SPARSE_INDEX; |
| 1759 | return; |
| 1760 | } |
| 1761 | |
Elijah Newren | 051df3c | 2020-06-18 20:49:57 +0000 | [diff] [blame] | 1762 | for (i = 0; i < r->index->cache_nr; i++) { |
| 1763 | struct cache_entry *ce = r->index->cache[i]; |
| 1764 | if (ce_skip_worktree(ce)) |
| 1765 | skip_worktree++; |
| 1766 | } |
| 1767 | |
| 1768 | state->sparse_checkout_percentage = |
| 1769 | 100 - (100 * skip_worktree)/r->index->cache_nr; |
| 1770 | } |
| 1771 | |
Nguyễn Thái Ngọc Duy | 7884545 | 2018-11-10 06:48:50 +0100 | [diff] [blame] | 1772 | void wt_status_get_state(struct repository *r, |
| 1773 | struct wt_status_state *state, |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1774 | int get_detached_from) |
| 1775 | { |
| 1776 | struct stat st; |
brian m. carlson | e86ab2c | 2017-02-21 23:47:37 +0000 | [diff] [blame] | 1777 | struct object_id oid; |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1778 | enum replay_action action; |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1779 | |
Nguyễn Thái Ngọc Duy | 7884545 | 2018-11-10 06:48:50 +0100 | [diff] [blame] | 1780 | if (!stat(git_path_merge_head(r), &st)) { |
Johannes Schindelin | 982288e | 2018-11-12 15:26:02 -0800 | [diff] [blame] | 1781 | wt_status_check_rebase(NULL, state); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1782 | state->merge_in_progress = 1; |
Nguyễn Thái Ngọc Duy | 81eff27 | 2016-04-22 20:01:31 +0700 | [diff] [blame] | 1783 | } else if (wt_status_check_rebase(NULL, state)) { |
Nguyễn Thái Ngọc Duy | bcd522a | 2016-04-22 20:01:30 +0700 | [diff] [blame] | 1784 | ; /* all set */ |
Han-Wen Nienhuys | c8e4159 | 2020-08-21 16:59:35 +0000 | [diff] [blame] | 1785 | } else if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") && |
Ævar Arnfjörð Bjarmason | 4a93b89 | 2023-03-28 15:58:58 +0200 | [diff] [blame] | 1786 | !repo_get_oid(r, "CHERRY_PICK_HEAD", &oid)) { |
Nguyễn Thái Ngọc Duy | b9691db | 2013-03-13 18:42:50 +0700 | [diff] [blame] | 1787 | state->cherry_pick_in_progress = 1; |
brian m. carlson | 40f5555 | 2018-03-12 02:27:29 +0000 | [diff] [blame] | 1788 | oidcpy(&state->cherry_pick_head_oid, &oid); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1789 | } |
Nguyễn Thái Ngọc Duy | f5d067a | 2016-04-22 20:01:34 +0700 | [diff] [blame] | 1790 | wt_status_check_bisect(NULL, state); |
Han-Wen Nienhuys | b8825ef | 2020-08-21 16:59:37 +0000 | [diff] [blame] | 1791 | if (refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD") && |
Ævar Arnfjörð Bjarmason | 4a93b89 | 2023-03-28 15:58:58 +0200 | [diff] [blame] | 1792 | !repo_get_oid(r, "REVERT_HEAD", &oid)) { |
Matthieu Moy | db4ef44 | 2013-04-02 16:20:21 +0200 | [diff] [blame] | 1793 | state->revert_in_progress = 1; |
brian m. carlson | 40f5555 | 2018-03-12 02:27:29 +0000 | [diff] [blame] | 1794 | oidcpy(&state->revert_head_oid, &oid); |
Matthieu Moy | db4ef44 | 2013-04-02 16:20:21 +0200 | [diff] [blame] | 1795 | } |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1796 | if (!sequencer_get_last_command(r, &action)) { |
Jacob Keller | a096a88 | 2023-06-27 15:41:50 -0700 | [diff] [blame] | 1797 | if (action == REPLAY_PICK && !state->cherry_pick_in_progress) { |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1798 | state->cherry_pick_in_progress = 1; |
brian m. carlson | 1422844 | 2021-04-26 01:02:56 +0000 | [diff] [blame] | 1799 | oidcpy(&state->cherry_pick_head_oid, null_oid()); |
Jacob Keller | a096a88 | 2023-06-27 15:41:50 -0700 | [diff] [blame] | 1800 | } else if (action == REPLAY_REVERT && !state->revert_in_progress) { |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1801 | state->revert_in_progress = 1; |
brian m. carlson | 1422844 | 2021-04-26 01:02:56 +0000 | [diff] [blame] | 1802 | oidcpy(&state->revert_head_oid, null_oid()); |
Phillip Wood | 4a72486 | 2019-04-16 11:18:42 +0100 | [diff] [blame] | 1803 | } |
| 1804 | } |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1805 | if (get_detached_from) |
Nguyễn Thái Ngọc Duy | 7884545 | 2018-11-10 06:48:50 +0100 | [diff] [blame] | 1806 | wt_status_get_detached_from(r, state); |
Elijah Newren | 051df3c | 2020-06-18 20:49:57 +0000 | [diff] [blame] | 1807 | wt_status_check_sparse_checkout(r, state); |
Nguyễn Thái Ngọc Duy | b9691db | 2013-03-13 18:42:50 +0700 | [diff] [blame] | 1808 | } |
| 1809 | |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1810 | static void wt_longstatus_print_state(struct wt_status *s) |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1811 | { |
| 1812 | const char *state_color = color(WT_STATUS_HEADER, s); |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1813 | struct wt_status_state *state = &s->state; |
| 1814 | |
Johannes Schindelin | 982288e | 2018-11-12 15:26:02 -0800 | [diff] [blame] | 1815 | if (state->merge_in_progress) { |
| 1816 | if (state->rebase_interactive_in_progress) { |
| 1817 | show_rebase_information(s, state_color); |
| 1818 | fputs("\n", s->fp); |
| 1819 | } |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1820 | show_merge_in_progress(s, state_color); |
Johannes Schindelin | 982288e | 2018-11-12 15:26:02 -0800 | [diff] [blame] | 1821 | } else if (state->am_in_progress) |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1822 | show_am_in_progress(s, state_color); |
Nguyễn Thái Ngọc Duy | 3b691cc | 2013-03-13 18:42:51 +0700 | [diff] [blame] | 1823 | else if (state->rebase_in_progress || state->rebase_interactive_in_progress) |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1824 | show_rebase_in_progress(s, state_color); |
Nguyễn Thái Ngọc Duy | 3b691cc | 2013-03-13 18:42:51 +0700 | [diff] [blame] | 1825 | else if (state->cherry_pick_in_progress) |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1826 | show_cherry_pick_in_progress(s, state_color); |
Matthieu Moy | db4ef44 | 2013-04-02 16:20:21 +0200 | [diff] [blame] | 1827 | else if (state->revert_in_progress) |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1828 | show_revert_in_progress(s, state_color); |
Nguyễn Thái Ngọc Duy | 3b691cc | 2013-03-13 18:42:51 +0700 | [diff] [blame] | 1829 | if (state->bisect_in_progress) |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1830 | show_bisect_in_progress(s, state_color); |
Elijah Newren | 051df3c | 2020-06-18 20:49:57 +0000 | [diff] [blame] | 1831 | |
| 1832 | if (state->sparse_checkout_percentage != SPARSE_CHECKOUT_DISABLED) |
| 1833 | show_sparse_checkout_in_use(s, state_color); |
Lucien Kong | 83c750a | 2012-06-05 22:21:24 +0200 | [diff] [blame] | 1834 | } |
| 1835 | |
Jeff Hostetler | be7e795 | 2016-08-05 18:00:27 -0400 | [diff] [blame] | 1836 | static void wt_longstatus_print(struct wt_status *s) |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1837 | { |
Aleksi Aalto | 1d28232 | 2010-11-18 01:40:05 +0200 | [diff] [blame] | 1838 | const char *branch_color = color(WT_STATUS_ONBRANCH, s); |
| 1839 | const char *branch_status_color = color(WT_STATUS_HEADER, s); |
Rudy Rigot | ecbc23e | 2022-11-30 00:52:16 +0000 | [diff] [blame] | 1840 | enum fsmonitor_mode fsm_mode = fsm_settings__get_mode(s->repo); |
Jürgen Rühle | 98bf8a4 | 2007-01-02 20:26:23 +0100 | [diff] [blame] | 1841 | |
Junio C Hamano | bda324c | 2007-01-03 01:09:34 -0800 | [diff] [blame] | 1842 | if (s->branch) { |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 1843 | const char *on_what = _("On branch "); |
Junio C Hamano | bda324c | 2007-01-03 01:09:34 -0800 | [diff] [blame] | 1844 | const char *branch_name = s->branch; |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 1845 | if (!strcmp(branch_name, "HEAD")) { |
Aleksi Aalto | 1d28232 | 2010-11-18 01:40:05 +0200 | [diff] [blame] | 1846 | branch_status_color = color(WT_STATUS_NOBRANCH, s); |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1847 | if (s->state.rebase_in_progress || |
| 1848 | s->state.rebase_interactive_in_progress) { |
| 1849 | if (s->state.rebase_interactive_in_progress) |
Guillaume Pagès | df25e94 | 2015-06-30 15:01:13 +0200 | [diff] [blame] | 1850 | on_what = _("interactive rebase in progress; onto "); |
| 1851 | else |
| 1852 | on_what = _("rebase in progress; onto "); |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1853 | branch_name = s->state.onto; |
| 1854 | } else if (s->state.detached_from) { |
| 1855 | branch_name = s->state.detached_from; |
| 1856 | if (s->state.detached_at) |
Ævar Arnfjörð Bjarmason | 2708ce6 | 2021-01-07 10:51:52 +0100 | [diff] [blame] | 1857 | on_what = _("HEAD detached at "); |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1858 | else |
Ævar Arnfjörð Bjarmason | 2708ce6 | 2021-01-07 10:51:52 +0100 | [diff] [blame] | 1859 | on_what = _("HEAD detached from "); |
Nguyễn Thái Ngọc Duy | b397ea4 | 2013-03-13 18:42:52 +0700 | [diff] [blame] | 1860 | } else { |
| 1861 | branch_name = ""; |
| 1862 | on_what = _("Not currently on any branch."); |
| 1863 | } |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 1864 | } else |
| 1865 | skip_prefix(branch_name, "refs/heads/", &branch_name); |
Felipe Contreras | 7d7d680 | 2014-05-04 01:12:55 -0500 | [diff] [blame] | 1866 | status_printf(s, color(WT_STATUS_HEADER, s), "%s", ""); |
Jonathan Nieder | b926c0d | 2011-02-25 23:11:37 -0600 | [diff] [blame] | 1867 | status_printf_more(s, branch_status_color, "%s", on_what); |
| 1868 | status_printf_more(s, branch_color, "%s\n", branch_name); |
Junio C Hamano | b6975ab | 2008-07-02 00:52:16 -0700 | [diff] [blame] | 1869 | if (!s->is_initial) |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1870 | wt_longstatus_print_tracking(s); |
Junio C Hamano | bda324c | 2007-01-03 01:09:34 -0800 | [diff] [blame] | 1871 | } |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1872 | |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 1873 | wt_longstatus_print_state(s); |
Nguyễn Thái Ngọc Duy | 3b691cc | 2013-03-13 18:42:51 +0700 | [diff] [blame] | 1874 | |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1875 | if (s->is_initial) { |
Felipe Contreras | 7d7d680 | 2014-05-04 01:12:55 -0500 | [diff] [blame] | 1876 | status_printf_ln(s, color(WT_STATUS_HEADER, s), "%s", ""); |
Kaartic Sivaraam | 4ddb135 | 2017-06-21 23:46:14 +0530 | [diff] [blame] | 1877 | status_printf_ln(s, color(WT_STATUS_HEADER, s), |
| 1878 | s->commit_template |
| 1879 | ? _("Initial commit") |
| 1880 | : _("No commits yet")); |
Felipe Contreras | 7d7d680 | 2014-05-04 01:12:55 -0500 | [diff] [blame] | 1881 | status_printf_ln(s, color(WT_STATUS_HEADER, s), "%s", ""); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1882 | } |
| 1883 | |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1884 | wt_longstatus_print_updated(s); |
| 1885 | wt_longstatus_print_unmerged(s); |
| 1886 | wt_longstatus_print_changed(s); |
Jens Lehmann | 46a958b | 2010-06-25 16:56:47 +0200 | [diff] [blame] | 1887 | if (s->submodule_summary && |
| 1888 | (!s->ignore_submodule_arg || |
| 1889 | strcmp(s->ignore_submodule_arg, "all"))) { |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1890 | wt_longstatus_print_submodule_summary(s, 0); /* staged */ |
| 1891 | wt_longstatus_print_submodule_summary(s, 1); /* unstaged */ |
Jens Lehmann | f17a5d3 | 2010-01-17 20:42:31 +0100 | [diff] [blame] | 1892 | } |
Junio C Hamano | 2381e39 | 2010-04-10 00:33:17 -0700 | [diff] [blame] | 1893 | if (s->show_untracked_files) { |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1894 | wt_longstatus_print_other(s, &s->untracked, _("Untracked files"), "add"); |
Jameson Miller | eec0f7f | 2017-10-30 13:21:37 -0400 | [diff] [blame] | 1895 | if (s->show_ignored_mode) |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1896 | wt_longstatus_print_other(s, &s->ignored, _("Ignored files"), "add -f"); |
Rudy Rigot | ecbc23e | 2022-11-30 00:52:16 +0000 | [diff] [blame] | 1897 | if (advice_enabled(ADVICE_STATUS_U_OPTION) && uf_was_slow(s)) { |
Felipe Contreras | 7d7d680 | 2014-05-04 01:12:55 -0500 | [diff] [blame] | 1898 | status_printf_ln(s, GIT_COLOR_NORMAL, "%s", ""); |
Rudy Rigot | ecbc23e | 2022-11-30 00:52:16 +0000 | [diff] [blame] | 1899 | if (fsm_mode > FSMONITOR_MODE_DISABLED) { |
| 1900 | status_printf_ln(s, GIT_COLOR_NORMAL, |
| 1901 | _("It took %.2f seconds to enumerate untracked files,\n" |
| 1902 | "but the results were cached, and subsequent runs may be faster."), |
| 1903 | s->untracked_in_ms / 1000.0); |
| 1904 | } else { |
| 1905 | status_printf_ln(s, GIT_COLOR_NORMAL, |
| 1906 | _("It took %.2f seconds to enumerate untracked files."), |
| 1907 | s->untracked_in_ms / 1000.0); |
| 1908 | } |
Nguyễn Thái Ngọc Duy | 6a38ef2 | 2013-03-13 19:59:16 +0700 | [diff] [blame] | 1909 | status_printf_ln(s, GIT_COLOR_NORMAL, |
Rudy Rigot | ecbc23e | 2022-11-30 00:52:16 +0000 | [diff] [blame] | 1910 | _("See 'git help status' for information on how to improve this.")); |
| 1911 | status_printf_ln(s, GIT_COLOR_NORMAL, "%s", ""); |
Nguyễn Thái Ngọc Duy | 6a38ef2 | 2013-03-13 19:59:16 +0700 | [diff] [blame] | 1912 | } |
Stephen P. Smith | 6fa9019 | 2018-09-05 17:53:27 -0700 | [diff] [blame] | 1913 | } else if (s->committable) |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 1914 | status_printf_ln(s, GIT_COLOR_NORMAL, _("Untracked files not listed%s"), |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1915 | s->hints |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 1916 | ? _(" (use -u option to show untracked files)") : ""); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1917 | |
Jeff King | 1324fb6 | 2008-11-12 03:23:37 -0500 | [diff] [blame] | 1918 | if (s->verbose) |
Jeff Hostetler | 957a0fe | 2016-08-05 18:00:26 -0400 | [diff] [blame] | 1919 | wt_longstatus_print_verbose(s); |
Stephen P. Smith | 6fa9019 | 2018-09-05 17:53:27 -0700 | [diff] [blame] | 1920 | if (!s->committable) { |
Jürgen Rühle | 6e458bf | 2007-01-02 20:26:22 +0100 | [diff] [blame] | 1921 | if (s->amend) |
Ævar Arnfjörð Bjarmason | 355ec7a | 2011-02-22 23:42:13 +0000 | [diff] [blame] | 1922 | status_printf_ln(s, GIT_COLOR_NORMAL, _("No changes")); |
Junio C Hamano | 37d07f8 | 2007-12-12 19:09:16 -0800 | [diff] [blame] | 1923 | else if (s->nowarn) |
| 1924 | ; /* nothing */ |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 1925 | else if (s->workdir_dirty) { |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1926 | if (s->hints) |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1927 | fprintf(s->fp, _("no changes added to commit " |
| 1928 | "(use \"git add\" and/or " |
| 1929 | "\"git commit -a\")\n")); |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 1930 | else |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1931 | fprintf(s->fp, _("no changes added to " |
| 1932 | "commit\n")); |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 1933 | } else if (s->untracked.nr) { |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1934 | if (s->hints) |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1935 | fprintf(s->fp, _("nothing added to commit but " |
| 1936 | "untracked files present (use " |
| 1937 | "\"git add\" to track)\n")); |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 1938 | else |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1939 | fprintf(s->fp, _("nothing added to commit but " |
| 1940 | "untracked files present\n")); |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 1941 | } else if (s->is_initial) { |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1942 | if (s->hints) |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1943 | fprintf(s->fp, _("nothing to commit (create/" |
| 1944 | "copy files and use \"git " |
| 1945 | "add\" to track)\n")); |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 1946 | else |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1947 | fprintf(s->fp, _("nothing to commit\n")); |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 1948 | } else if (!s->show_untracked_files) { |
Matthieu Moy | 6a964f5 | 2013-09-12 12:50:05 +0200 | [diff] [blame] | 1949 | if (s->hints) |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1950 | fprintf(s->fp, _("nothing to commit (use -u to " |
| 1951 | "show untracked files)\n")); |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 1952 | else |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1953 | fprintf(s->fp, _("nothing to commit\n")); |
Nguyễn Thái Ngọc Duy | 50bd8b7 | 2012-09-06 22:16:50 +0700 | [diff] [blame] | 1954 | } else |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1955 | fprintf(s->fp, _("nothing to commit, working tree " |
| 1956 | "clean\n")); |
Jürgen Rühle | 6e458bf | 2007-01-02 20:26:22 +0100 | [diff] [blame] | 1957 | } |
Liam Beguin | c1b5d01 | 2017-06-17 18:30:51 -0400 | [diff] [blame] | 1958 | if(s->show_stash) |
| 1959 | wt_longstatus_print_stash_summary(s); |
Jeff King | c91f0d9 | 2006-09-08 04:05:34 -0400 | [diff] [blame] | 1960 | } |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 1961 | |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 1962 | static void wt_shortstatus_unmerged(struct string_list_item *it, |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 1963 | struct wt_status *s) |
| 1964 | { |
| 1965 | struct wt_status_change_data *d = it->util; |
| 1966 | const char *how = "??"; |
| 1967 | |
| 1968 | switch (d->stagemask) { |
| 1969 | case 1: how = "DD"; break; /* both deleted */ |
| 1970 | case 2: how = "AU"; break; /* added by us */ |
| 1971 | case 3: how = "UD"; break; /* deleted by them */ |
| 1972 | case 4: how = "UA"; break; /* added by them */ |
| 1973 | case 5: how = "DU"; break; /* deleted by us */ |
| 1974 | case 6: how = "AA"; break; /* both added */ |
| 1975 | case 7: how = "UU"; break; /* both modified */ |
| 1976 | } |
Michael J Gruber | 3fe2a89 | 2009-12-05 16:04:38 +0100 | [diff] [blame] | 1977 | color_fprintf(s->fp, color(WT_STATUS_UNMERGED, s), "%s", how); |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 1978 | if (s->null_termination) { |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1979 | fprintf(s->fp, " %s%c", it->string, 0); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 1980 | } else { |
| 1981 | struct strbuf onebuf = STRBUF_INIT; |
| 1982 | const char *one; |
Junio C Hamano | a361dd3 | 2020-09-10 10:01:57 -0700 | [diff] [blame] | 1983 | one = quote_path(it->string, s->prefix, &onebuf, QUOTE_PATH_QUOTE_SP); |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1984 | fprintf(s->fp, " %s\n", one); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 1985 | strbuf_release(&onebuf); |
| 1986 | } |
| 1987 | } |
| 1988 | |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 1989 | static void wt_shortstatus_status(struct string_list_item *it, |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 1990 | struct wt_status *s) |
| 1991 | { |
| 1992 | struct wt_status_change_data *d = it->util; |
| 1993 | |
Michael J Gruber | 3fe2a89 | 2009-12-05 16:04:38 +0100 | [diff] [blame] | 1994 | if (d->index_status) |
| 1995 | color_fprintf(s->fp, color(WT_STATUS_UPDATED, s), "%c", d->index_status); |
| 1996 | else |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 1997 | fputc(' ', s->fp); |
Michael J Gruber | 3fe2a89 | 2009-12-05 16:04:38 +0100 | [diff] [blame] | 1998 | if (d->worktree_status) |
| 1999 | color_fprintf(s->fp, color(WT_STATUS_CHANGED, s), "%c", d->worktree_status); |
| 2000 | else |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 2001 | fputc(' ', s->fp); |
| 2002 | fputc(' ', s->fp); |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 2003 | if (s->null_termination) { |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 2004 | fprintf(s->fp, "%s%c", it->string, 0); |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 2005 | if (d->rename_source) |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 2006 | fprintf(s->fp, "%s%c", d->rename_source, 0); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2007 | } else { |
| 2008 | struct strbuf onebuf = STRBUF_INIT; |
| 2009 | const char *one; |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 2010 | |
| 2011 | if (d->rename_source) { |
Junio C Hamano | f3fc4a1 | 2020-09-10 10:01:55 -0700 | [diff] [blame] | 2012 | one = quote_path(d->rename_source, s->prefix, &onebuf, |
| 2013 | QUOTE_PATH_QUOTE_SP); |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 2014 | fprintf(s->fp, "%s -> ", one); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2015 | strbuf_release(&onebuf); |
| 2016 | } |
Junio C Hamano | f3fc4a1 | 2020-09-10 10:01:55 -0700 | [diff] [blame] | 2017 | one = quote_path(it->string, s->prefix, &onebuf, QUOTE_PATH_QUOTE_SP); |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 2018 | fprintf(s->fp, "%s\n", one); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2019 | strbuf_release(&onebuf); |
| 2020 | } |
| 2021 | } |
| 2022 | |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 2023 | static void wt_shortstatus_other(struct string_list_item *it, |
Junio C Hamano | 2381e39 | 2010-04-10 00:33:17 -0700 | [diff] [blame] | 2024 | struct wt_status *s, const char *sign) |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2025 | { |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 2026 | if (s->null_termination) { |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 2027 | fprintf(s->fp, "%s %s%c", sign, it->string, 0); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2028 | } else { |
| 2029 | struct strbuf onebuf = STRBUF_INIT; |
| 2030 | const char *one; |
Junio C Hamano | a361dd3 | 2020-09-10 10:01:57 -0700 | [diff] [blame] | 2031 | one = quote_path(it->string, s->prefix, &onebuf, QUOTE_PATH_QUOTE_SP); |
Junio C Hamano | c1909e7 | 2010-05-01 22:05:14 -0700 | [diff] [blame] | 2032 | color_fprintf(s->fp, color(WT_STATUS_UNTRACKED, s), "%s", sign); |
Martin Ågren | 8f7e3de | 2020-09-27 15:15:42 +0200 | [diff] [blame] | 2033 | fprintf(s->fp, " %s\n", one); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2034 | strbuf_release(&onebuf); |
| 2035 | } |
| 2036 | } |
| 2037 | |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2038 | static void wt_shortstatus_print_tracking(struct wt_status *s) |
| 2039 | { |
| 2040 | struct branch *branch; |
| 2041 | const char *header_color = color(WT_STATUS_HEADER, s); |
| 2042 | const char *branch_color_local = color(WT_STATUS_LOCAL_BRANCH, s); |
| 2043 | const char *branch_color_remote = color(WT_STATUS_REMOTE_BRANCH, s); |
| 2044 | |
| 2045 | const char *base; |
René Scharfe | 5e8d272 | 2017-07-08 12:51:01 +0200 | [diff] [blame] | 2046 | char *short_base; |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2047 | const char *branch_name; |
Jeff Hostetler | 3ca1897 | 2018-01-09 18:50:17 +0000 | [diff] [blame] | 2048 | int num_ours, num_theirs, sti; |
Jiang Xin | f2e0873 | 2013-08-26 15:02:48 +0800 | [diff] [blame] | 2049 | int upstream_is_gone = 0; |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2050 | |
| 2051 | color_fprintf(s->fp, color(WT_STATUS_HEADER, s), "## "); |
| 2052 | |
| 2053 | if (!s->branch) |
| 2054 | return; |
| 2055 | branch_name = s->branch; |
| 2056 | |
Michael J Gruber | b9e2bc5 | 2017-03-14 17:02:02 +0100 | [diff] [blame] | 2057 | #define LABEL(string) (s->no_gettext ? (string) : _(string)) |
| 2058 | |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2059 | if (s->is_initial) |
Kaartic Sivaraam | 4ddb135 | 2017-06-21 23:46:14 +0530 | [diff] [blame] | 2060 | color_fprintf(s->fp, header_color, LABEL(N_("No commits yet on "))); |
Jiang Xin | f2e0873 | 2013-08-26 15:02:48 +0800 | [diff] [blame] | 2061 | |
René Scharfe | baf0a3e | 2015-10-31 18:36:35 +0100 | [diff] [blame] | 2062 | if (!strcmp(s->branch, "HEAD")) { |
| 2063 | color_fprintf(s->fp, color(WT_STATUS_NOBRANCH, s), "%s", |
Michael J Gruber | b9e2bc5 | 2017-03-14 17:02:02 +0100 | [diff] [blame] | 2064 | LABEL(N_("HEAD (no branch)"))); |
René Scharfe | baf0a3e | 2015-10-31 18:36:35 +0100 | [diff] [blame] | 2065 | goto conclude; |
| 2066 | } |
| 2067 | |
René Scharfe | c72b49d | 2015-10-31 18:37:43 +0100 | [diff] [blame] | 2068 | skip_prefix(branch_name, "refs/heads/", &branch_name); |
René Scharfe | baf0a3e | 2015-10-31 18:36:35 +0100 | [diff] [blame] | 2069 | |
René Scharfe | 8d8325f | 2015-10-31 18:37:12 +0100 | [diff] [blame] | 2070 | branch = branch_get(branch_name); |
René Scharfe | baf0a3e | 2015-10-31 18:36:35 +0100 | [diff] [blame] | 2071 | |
Jiang Xin | f2e0873 | 2013-08-26 15:02:48 +0800 | [diff] [blame] | 2072 | color_fprintf(s->fp, branch_color_local, "%s", branch_name); |
| 2073 | |
Jeff Hostetler | 3ca1897 | 2018-01-09 18:50:17 +0000 | [diff] [blame] | 2074 | sti = stat_tracking_info(branch, &num_ours, &num_theirs, &base, |
Damien Robert | c646d09 | 2019-04-16 14:16:46 +0200 | [diff] [blame] | 2075 | 0, s->ahead_behind_flags); |
Jeff Hostetler | 3ca1897 | 2018-01-09 18:50:17 +0000 | [diff] [blame] | 2076 | if (sti < 0) { |
René Scharfe | bcf8cc2 | 2015-10-31 18:36:01 +0100 | [diff] [blame] | 2077 | if (!base) |
| 2078 | goto conclude; |
Jeff King | 979cb24 | 2015-05-21 20:49:11 -0400 | [diff] [blame] | 2079 | |
Jiang Xin | f2e0873 | 2013-08-26 15:02:48 +0800 | [diff] [blame] | 2080 | upstream_is_gone = 1; |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2081 | } |
| 2082 | |
René Scharfe | 5e8d272 | 2017-07-08 12:51:01 +0200 | [diff] [blame] | 2083 | short_base = shorten_unambiguous_ref(base, 0); |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2084 | color_fprintf(s->fp, header_color, "..."); |
René Scharfe | 5e8d272 | 2017-07-08 12:51:01 +0200 | [diff] [blame] | 2085 | color_fprintf(s->fp, branch_color_remote, "%s", short_base); |
| 2086 | free(short_base); |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2087 | |
Jeff Hostetler | 3ca1897 | 2018-01-09 18:50:17 +0000 | [diff] [blame] | 2088 | if (!upstream_is_gone && !sti) |
René Scharfe | bcf8cc2 | 2015-10-31 18:36:01 +0100 | [diff] [blame] | 2089 | goto conclude; |
Jiang Xin | f223459 | 2013-08-26 15:02:49 +0800 | [diff] [blame] | 2090 | |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2091 | color_fprintf(s->fp, header_color, " ["); |
Jiang Xin | f2e0873 | 2013-08-26 15:02:48 +0800 | [diff] [blame] | 2092 | if (upstream_is_gone) { |
Matthieu Moy | 7a76c28 | 2014-03-20 13:12:41 +0100 | [diff] [blame] | 2093 | color_fprintf(s->fp, header_color, LABEL(N_("gone"))); |
Jeff Hostetler | 3ca1897 | 2018-01-09 18:50:17 +0000 | [diff] [blame] | 2094 | } else if (s->ahead_behind_flags == AHEAD_BEHIND_QUICK) { |
| 2095 | color_fprintf(s->fp, header_color, LABEL(N_("different"))); |
Jiang Xin | f2e0873 | 2013-08-26 15:02:48 +0800 | [diff] [blame] | 2096 | } else if (!num_ours) { |
Matthieu Moy | 7a76c28 | 2014-03-20 13:12:41 +0100 | [diff] [blame] | 2097 | color_fprintf(s->fp, header_color, LABEL(N_("behind "))); |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2098 | color_fprintf(s->fp, branch_color_remote, "%d", num_theirs); |
| 2099 | } else if (!num_theirs) { |
Michael J Gruber | df22724 | 2016-03-14 16:30:33 +0100 | [diff] [blame] | 2100 | color_fprintf(s->fp, header_color, LABEL(N_("ahead "))); |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2101 | color_fprintf(s->fp, branch_color_local, "%d", num_ours); |
| 2102 | } else { |
Michael J Gruber | df22724 | 2016-03-14 16:30:33 +0100 | [diff] [blame] | 2103 | color_fprintf(s->fp, header_color, LABEL(N_("ahead "))); |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2104 | color_fprintf(s->fp, branch_color_local, "%d", num_ours); |
Matthieu Moy | 7a76c28 | 2014-03-20 13:12:41 +0100 | [diff] [blame] | 2105 | color_fprintf(s->fp, header_color, ", %s", LABEL(N_("behind "))); |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2106 | color_fprintf(s->fp, branch_color_remote, "%d", num_theirs); |
| 2107 | } |
| 2108 | |
Jeff King | a598523 | 2012-05-07 17:02:18 -0400 | [diff] [blame] | 2109 | color_fprintf(s->fp, header_color, "]"); |
René Scharfe | bcf8cc2 | 2015-10-31 18:36:01 +0100 | [diff] [blame] | 2110 | conclude: |
Jeff King | a598523 | 2012-05-07 17:02:18 -0400 | [diff] [blame] | 2111 | fputc(s->null_termination ? '\0' : '\n', s->fp); |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2112 | } |
| 2113 | |
Jeff Hostetler | be7e795 | 2016-08-05 18:00:27 -0400 | [diff] [blame] | 2114 | static void wt_shortstatus_print(struct wt_status *s) |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2115 | { |
Stefan Beller | d4aae45 | 2017-03-16 14:36:19 -0700 | [diff] [blame] | 2116 | struct string_list_item *it; |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2117 | |
Jeff King | d4a6bf1 | 2012-05-07 17:09:04 -0400 | [diff] [blame] | 2118 | if (s->show_branch) |
Daniel Knittl-Frank | 05a59a0 | 2010-05-25 15:45:51 +0200 | [diff] [blame] | 2119 | wt_shortstatus_print_tracking(s); |
| 2120 | |
Stefan Beller | d4aae45 | 2017-03-16 14:36:19 -0700 | [diff] [blame] | 2121 | for_each_string_list_item(it, &s->change) { |
| 2122 | struct wt_status_change_data *d = it->util; |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2123 | |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2124 | if (d->stagemask) |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 2125 | wt_shortstatus_unmerged(it, s); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2126 | else |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 2127 | wt_shortstatus_status(it, s); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2128 | } |
Stefan Beller | d4aae45 | 2017-03-16 14:36:19 -0700 | [diff] [blame] | 2129 | for_each_string_list_item(it, &s->untracked) |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 2130 | wt_shortstatus_other(it, s, "??"); |
Junio C Hamano | 2381e39 | 2010-04-10 00:33:17 -0700 | [diff] [blame] | 2131 | |
Stefan Beller | d4aae45 | 2017-03-16 14:36:19 -0700 | [diff] [blame] | 2132 | for_each_string_list_item(it, &s->ignored) |
Jeff King | 3207a3a | 2012-05-07 15:44:44 -0400 | [diff] [blame] | 2133 | wt_shortstatus_other(it, s, "!!"); |
Michael J Gruber | 84dbe7b | 2009-12-05 16:04:37 +0100 | [diff] [blame] | 2134 | } |
Jeff King | 4a7cc2f | 2009-12-07 00:17:15 -0500 | [diff] [blame] | 2135 | |
Jeff Hostetler | be7e795 | 2016-08-05 18:00:27 -0400 | [diff] [blame] | 2136 | static void wt_porcelain_print(struct wt_status *s) |
Jeff King | 4a7cc2f | 2009-12-07 00:17:15 -0500 | [diff] [blame] | 2137 | { |
| 2138 | s->use_color = 0; |
Jeff King | 8661768 | 2009-12-07 00:26:25 -0500 | [diff] [blame] | 2139 | s->relative_paths = 0; |
| 2140 | s->prefix = NULL; |
Matthieu Moy | 7a76c28 | 2014-03-20 13:12:41 +0100 | [diff] [blame] | 2141 | s->no_gettext = 1; |
Jeff King | d4a6bf1 | 2012-05-07 17:09:04 -0400 | [diff] [blame] | 2142 | wt_shortstatus_print(s); |
Jeff King | 4a7cc2f | 2009-12-07 00:17:15 -0500 | [diff] [blame] | 2143 | } |
Jeff Hostetler | be7e795 | 2016-08-05 18:00:27 -0400 | [diff] [blame] | 2144 | |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2145 | /* |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2146 | * Print branch information for porcelain v2 output. These lines |
| 2147 | * are printed when the '--branch' parameter is given. |
| 2148 | * |
| 2149 | * # branch.oid <commit><eol> |
| 2150 | * # branch.head <head><eol> |
| 2151 | * [# branch.upstream <upstream><eol> |
| 2152 | * [# branch.ab +<ahead> -<behind><eol>]] |
| 2153 | * |
Elijah Newren | 6d12b53 | 2020-07-28 20:45:38 +0000 | [diff] [blame] | 2154 | * <commit> ::= the current commit hash or the literal |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2155 | * "(initial)" to indicate an initialized repo |
| 2156 | * with no commits. |
| 2157 | * |
| 2158 | * <head> ::= <branch_name> the current branch name or |
| 2159 | * "(detached)" literal when detached head or |
| 2160 | * "(unknown)" when something is wrong. |
| 2161 | * |
| 2162 | * <upstream> ::= the upstream branch name, when set. |
| 2163 | * |
Jeff Hostetler | fd9b544 | 2018-01-09 18:50:16 +0000 | [diff] [blame] | 2164 | * <ahead> ::= integer ahead value or '?'. |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2165 | * |
Jeff Hostetler | fd9b544 | 2018-01-09 18:50:16 +0000 | [diff] [blame] | 2166 | * <behind> ::= integer behind value or '?'. |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2167 | * |
| 2168 | * The end-of-line is defined by the -z flag. |
| 2169 | * |
| 2170 | * <eol> ::= NUL when -z, |
| 2171 | * LF when NOT -z. |
| 2172 | * |
Jeff Hostetler | fd9b544 | 2018-01-09 18:50:16 +0000 | [diff] [blame] | 2173 | * When an upstream is set and present, the 'branch.ab' line will |
| 2174 | * be printed with the ahead/behind counts for the branch and the |
| 2175 | * upstream. When AHEAD_BEHIND_QUICK is requested and the branches |
| 2176 | * are different, '?' will be substituted for the actual count. |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2177 | */ |
| 2178 | static void wt_porcelain_v2_print_tracking(struct wt_status *s) |
| 2179 | { |
| 2180 | struct branch *branch; |
| 2181 | const char *base; |
| 2182 | const char *branch_name; |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2183 | int ab_info, nr_ahead, nr_behind; |
| 2184 | char eol = s->null_termination ? '\0' : '\n'; |
| 2185 | |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2186 | fprintf(s->fp, "# branch.oid %s%c", |
brian m. carlson | e0cb7cd | 2019-08-18 20:04:21 +0000 | [diff] [blame] | 2187 | (s->is_initial ? "(initial)" : oid_to_hex(&s->oid_commit)), |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2188 | eol); |
| 2189 | |
| 2190 | if (!s->branch) |
| 2191 | fprintf(s->fp, "# branch.head %s%c", "(unknown)", eol); |
| 2192 | else { |
| 2193 | if (!strcmp(s->branch, "HEAD")) { |
| 2194 | fprintf(s->fp, "# branch.head %s%c", "(detached)", eol); |
| 2195 | |
Stephen P. Smith | 73ba5d7 | 2018-09-30 07:12:45 -0700 | [diff] [blame] | 2196 | if (s->state.rebase_in_progress || |
| 2197 | s->state.rebase_interactive_in_progress) |
| 2198 | branch_name = s->state.onto; |
| 2199 | else if (s->state.detached_from) |
| 2200 | branch_name = s->state.detached_from; |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2201 | else |
| 2202 | branch_name = ""; |
| 2203 | } else { |
| 2204 | branch_name = NULL; |
| 2205 | skip_prefix(s->branch, "refs/heads/", &branch_name); |
| 2206 | |
| 2207 | fprintf(s->fp, "# branch.head %s%c", branch_name, eol); |
| 2208 | } |
| 2209 | |
| 2210 | /* Lookup stats on the upstream tracking branch, if set. */ |
| 2211 | branch = branch_get(branch_name); |
| 2212 | base = NULL; |
Jeff Hostetler | fd9b544 | 2018-01-09 18:50:16 +0000 | [diff] [blame] | 2213 | ab_info = stat_tracking_info(branch, &nr_ahead, &nr_behind, |
Damien Robert | c646d09 | 2019-04-16 14:16:46 +0200 | [diff] [blame] | 2214 | &base, 0, s->ahead_behind_flags); |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2215 | if (base) { |
| 2216 | base = shorten_unambiguous_ref(base, 0); |
| 2217 | fprintf(s->fp, "# branch.upstream %s%c", base, eol); |
| 2218 | free((char *)base); |
| 2219 | |
Jeff Hostetler | fd9b544 | 2018-01-09 18:50:16 +0000 | [diff] [blame] | 2220 | if (ab_info > 0) { |
| 2221 | /* different */ |
| 2222 | if (nr_ahead || nr_behind) |
| 2223 | fprintf(s->fp, "# branch.ab +%d -%d%c", |
| 2224 | nr_ahead, nr_behind, eol); |
| 2225 | else |
| 2226 | fprintf(s->fp, "# branch.ab +? -?%c", |
| 2227 | eol); |
| 2228 | } else if (!ab_info) { |
| 2229 | /* same */ |
| 2230 | fprintf(s->fp, "# branch.ab +0 -0%c", eol); |
| 2231 | } |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2232 | } |
| 2233 | } |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2234 | } |
| 2235 | |
| 2236 | /* |
Øystein Walle | 2e59e78 | 2021-10-22 00:25:32 +0200 | [diff] [blame] | 2237 | * Print the stash count in a porcelain-friendly format |
| 2238 | */ |
| 2239 | static void wt_porcelain_v2_print_stash(struct wt_status *s) |
| 2240 | { |
| 2241 | int stash_count = count_stash_entries(); |
| 2242 | char eol = s->null_termination ? '\0' : '\n'; |
| 2243 | |
| 2244 | if (stash_count > 0) |
| 2245 | fprintf(s->fp, "# stash %d%c", stash_count, eol); |
| 2246 | } |
| 2247 | |
| 2248 | /* |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2249 | * Convert various submodule status values into a |
| 2250 | * fixed-length string of characters in the buffer provided. |
| 2251 | */ |
| 2252 | static void wt_porcelain_v2_submodule_state( |
| 2253 | struct wt_status_change_data *d, |
| 2254 | char sub[5]) |
| 2255 | { |
| 2256 | if (S_ISGITLINK(d->mode_head) || |
| 2257 | S_ISGITLINK(d->mode_index) || |
| 2258 | S_ISGITLINK(d->mode_worktree)) { |
| 2259 | sub[0] = 'S'; |
| 2260 | sub[1] = d->new_submodule_commits ? 'C' : '.'; |
| 2261 | sub[2] = (d->dirty_submodule & DIRTY_SUBMODULE_MODIFIED) ? 'M' : '.'; |
| 2262 | sub[3] = (d->dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) ? 'U' : '.'; |
| 2263 | } else { |
| 2264 | sub[0] = 'N'; |
| 2265 | sub[1] = '.'; |
| 2266 | sub[2] = '.'; |
| 2267 | sub[3] = '.'; |
| 2268 | } |
| 2269 | sub[4] = 0; |
| 2270 | } |
| 2271 | |
| 2272 | /* |
| 2273 | * Fix-up changed entries before we print them. |
| 2274 | */ |
Jeff King | 13a1781 | 2019-05-09 17:30:19 -0400 | [diff] [blame] | 2275 | static void wt_porcelain_v2_fix_up_changed(struct string_list_item *it) |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2276 | { |
| 2277 | struct wt_status_change_data *d = it->util; |
| 2278 | |
| 2279 | if (!d->index_status) { |
| 2280 | /* |
| 2281 | * This entry is unchanged in the index (relative to the head). |
| 2282 | * Therefore, the collect_updated_cb was never called for this |
| 2283 | * entry (during the head-vs-index scan) and so the head column |
| 2284 | * fields were never set. |
| 2285 | * |
| 2286 | * We must have data for the index column (from the |
| 2287 | * index-vs-worktree scan (otherwise, this entry should not be |
| 2288 | * in the list of changes)). |
| 2289 | * |
| 2290 | * Copy index column fields to the head column, so that our |
| 2291 | * output looks complete. |
| 2292 | */ |
| 2293 | assert(d->mode_head == 0); |
| 2294 | d->mode_head = d->mode_index; |
| 2295 | oidcpy(&d->oid_head, &d->oid_index); |
| 2296 | } |
| 2297 | |
| 2298 | if (!d->worktree_status) { |
| 2299 | /* |
| 2300 | * This entry is unchanged in the worktree (relative to the index). |
| 2301 | * Therefore, the collect_changed_cb was never called for this entry |
| 2302 | * (during the index-vs-worktree scan) and so the worktree column |
| 2303 | * fields were never set. |
| 2304 | * |
| 2305 | * We must have data for the index column (from the head-vs-index |
| 2306 | * scan). |
| 2307 | * |
| 2308 | * Copy the index column fields to the worktree column so that |
| 2309 | * our output looks complete. |
| 2310 | * |
| 2311 | * Note that we only have a mode field in the worktree column |
| 2312 | * because the scan code tries really hard to not have to compute it. |
| 2313 | */ |
| 2314 | assert(d->mode_worktree == 0); |
| 2315 | d->mode_worktree = d->mode_index; |
| 2316 | } |
| 2317 | } |
| 2318 | |
| 2319 | /* |
| 2320 | * Print porcelain v2 info for tracked entries with changes. |
| 2321 | */ |
| 2322 | static void wt_porcelain_v2_print_changed_entry( |
| 2323 | struct string_list_item *it, |
| 2324 | struct wt_status *s) |
| 2325 | { |
| 2326 | struct wt_status_change_data *d = it->util; |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 2327 | struct strbuf buf = STRBUF_INIT; |
| 2328 | struct strbuf buf_from = STRBUF_INIT; |
| 2329 | const char *path = NULL; |
| 2330 | const char *path_from = NULL; |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2331 | char key[3]; |
| 2332 | char submodule_token[5]; |
| 2333 | char sep_char, eol_char; |
| 2334 | |
Jeff King | 13a1781 | 2019-05-09 17:30:19 -0400 | [diff] [blame] | 2335 | wt_porcelain_v2_fix_up_changed(it); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2336 | wt_porcelain_v2_submodule_state(d, submodule_token); |
| 2337 | |
| 2338 | key[0] = d->index_status ? d->index_status : '.'; |
| 2339 | key[1] = d->worktree_status ? d->worktree_status : '.'; |
| 2340 | key[2] = 0; |
| 2341 | |
| 2342 | if (s->null_termination) { |
| 2343 | /* |
| 2344 | * In -z mode, we DO NOT C-quote pathnames. Current path is ALWAYS first. |
| 2345 | * A single NUL character separates them. |
| 2346 | */ |
| 2347 | sep_char = '\0'; |
| 2348 | eol_char = '\0'; |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 2349 | path = it->string; |
| 2350 | path_from = d->rename_source; |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2351 | } else { |
| 2352 | /* |
| 2353 | * Path(s) are C-quoted if necessary. Current path is ALWAYS first. |
| 2354 | * The source path is only present when necessary. |
| 2355 | * A single TAB separates them (because paths can contain spaces |
| 2356 | * which are not escaped and C-quoting does escape TAB characters). |
| 2357 | */ |
| 2358 | sep_char = '\t'; |
| 2359 | eol_char = '\n'; |
Junio C Hamano | 88910c9 | 2020-09-10 10:01:54 -0700 | [diff] [blame] | 2360 | path = quote_path(it->string, s->prefix, &buf, 0); |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 2361 | if (d->rename_source) |
Junio C Hamano | 88910c9 | 2020-09-10 10:01:54 -0700 | [diff] [blame] | 2362 | path_from = quote_path(d->rename_source, s->prefix, &buf_from, 0); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2363 | } |
| 2364 | |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 2365 | if (path_from) |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2366 | fprintf(s->fp, "2 %s %s %06o %06o %06o %s %s %c%d %s%c%s%c", |
| 2367 | key, submodule_token, |
| 2368 | d->mode_head, d->mode_index, d->mode_worktree, |
| 2369 | oid_to_hex(&d->oid_head), oid_to_hex(&d->oid_index), |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 2370 | d->rename_status, d->rename_score, |
| 2371 | path, sep_char, path_from, eol_char); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2372 | else |
| 2373 | fprintf(s->fp, "1 %s %s %06o %06o %06o %s %s %s%c", |
| 2374 | key, submodule_token, |
| 2375 | d->mode_head, d->mode_index, d->mode_worktree, |
| 2376 | oid_to_hex(&d->oid_head), oid_to_hex(&d->oid_index), |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 2377 | path, eol_char); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2378 | |
Nguyễn Thái Ngọc Duy | 5134ccd | 2017-12-27 17:18:38 +0700 | [diff] [blame] | 2379 | strbuf_release(&buf); |
| 2380 | strbuf_release(&buf_from); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2381 | } |
| 2382 | |
| 2383 | /* |
| 2384 | * Print porcelain v2 status info for unmerged entries. |
| 2385 | */ |
| 2386 | static void wt_porcelain_v2_print_unmerged_entry( |
| 2387 | struct string_list_item *it, |
| 2388 | struct wt_status *s) |
| 2389 | { |
| 2390 | struct wt_status_change_data *d = it->util; |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2391 | struct index_state *istate = s->repo->index; |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2392 | const struct cache_entry *ce; |
| 2393 | struct strbuf buf_index = STRBUF_INIT; |
| 2394 | const char *path_index = NULL; |
| 2395 | int pos, stage, sum; |
| 2396 | struct { |
| 2397 | int mode; |
| 2398 | struct object_id oid; |
| 2399 | } stages[3]; |
| 2400 | char *key; |
| 2401 | char submodule_token[5]; |
| 2402 | char unmerged_prefix = 'u'; |
| 2403 | char eol_char = s->null_termination ? '\0' : '\n'; |
| 2404 | |
| 2405 | wt_porcelain_v2_submodule_state(d, submodule_token); |
| 2406 | |
| 2407 | switch (d->stagemask) { |
| 2408 | case 1: key = "DD"; break; /* both deleted */ |
| 2409 | case 2: key = "AU"; break; /* added by us */ |
| 2410 | case 3: key = "UD"; break; /* deleted by them */ |
| 2411 | case 4: key = "UA"; break; /* added by them */ |
| 2412 | case 5: key = "DU"; break; /* deleted by us */ |
| 2413 | case 6: key = "AA"; break; /* both added */ |
| 2414 | case 7: key = "UU"; break; /* both modified */ |
| 2415 | default: |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 2416 | BUG("unhandled unmerged status %x", d->stagemask); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2417 | } |
| 2418 | |
| 2419 | /* |
| 2420 | * Disregard d.aux.porcelain_v2 data that we accumulated |
| 2421 | * for the head and index columns during the scans and |
| 2422 | * replace with the actual stage data. |
| 2423 | * |
| 2424 | * Note that this is a last-one-wins for each the individual |
| 2425 | * stage [123] columns in the event of multiple cache entries |
| 2426 | * for same stage. |
| 2427 | */ |
| 2428 | memset(stages, 0, sizeof(stages)); |
| 2429 | sum = 0; |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2430 | pos = index_name_pos(istate, it->string, strlen(it->string)); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2431 | assert(pos < 0); |
| 2432 | pos = -pos-1; |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2433 | while (pos < istate->cache_nr) { |
| 2434 | ce = istate->cache[pos++]; |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2435 | stage = ce_stage(ce); |
| 2436 | if (strcmp(ce->name, it->string) || !stage) |
| 2437 | break; |
| 2438 | stages[stage - 1].mode = ce->ce_mode; |
René Scharfe | 8694769 | 2017-01-28 23:03:06 +0100 | [diff] [blame] | 2439 | oidcpy(&stages[stage - 1].oid, &ce->oid); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2440 | sum |= (1 << (stage - 1)); |
| 2441 | } |
| 2442 | if (sum != d->stagemask) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 2443 | BUG("observed stagemask 0x%x != expected stagemask 0x%x", sum, d->stagemask); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2444 | |
| 2445 | if (s->null_termination) |
| 2446 | path_index = it->string; |
| 2447 | else |
Junio C Hamano | 88910c9 | 2020-09-10 10:01:54 -0700 | [diff] [blame] | 2448 | path_index = quote_path(it->string, s->prefix, &buf_index, 0); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2449 | |
| 2450 | fprintf(s->fp, "%c %s %s %06o %06o %06o %06o %s %s %s %s%c", |
| 2451 | unmerged_prefix, key, submodule_token, |
| 2452 | stages[0].mode, /* stage 1 */ |
| 2453 | stages[1].mode, /* stage 2 */ |
| 2454 | stages[2].mode, /* stage 3 */ |
| 2455 | d->mode_worktree, |
| 2456 | oid_to_hex(&stages[0].oid), /* stage 1 */ |
| 2457 | oid_to_hex(&stages[1].oid), /* stage 2 */ |
| 2458 | oid_to_hex(&stages[2].oid), /* stage 3 */ |
| 2459 | path_index, |
| 2460 | eol_char); |
| 2461 | |
| 2462 | strbuf_release(&buf_index); |
| 2463 | } |
| 2464 | |
| 2465 | /* |
| 2466 | * Print porcelain V2 status info for untracked and ignored entries. |
| 2467 | */ |
| 2468 | static void wt_porcelain_v2_print_other( |
| 2469 | struct string_list_item *it, |
| 2470 | struct wt_status *s, |
| 2471 | char prefix) |
| 2472 | { |
| 2473 | struct strbuf buf = STRBUF_INIT; |
| 2474 | const char *path; |
| 2475 | char eol_char; |
| 2476 | |
| 2477 | if (s->null_termination) { |
| 2478 | path = it->string; |
| 2479 | eol_char = '\0'; |
| 2480 | } else { |
Junio C Hamano | 88910c9 | 2020-09-10 10:01:54 -0700 | [diff] [blame] | 2481 | path = quote_path(it->string, s->prefix, &buf, 0); |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2482 | eol_char = '\n'; |
| 2483 | } |
| 2484 | |
| 2485 | fprintf(s->fp, "%c %s%c", prefix, path, eol_char); |
| 2486 | |
| 2487 | strbuf_release(&buf); |
| 2488 | } |
| 2489 | |
| 2490 | /* |
| 2491 | * Print porcelain V2 status. |
| 2492 | * |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2493 | * [<v2_branch>] |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2494 | * [<v2_changed_items>]* |
| 2495 | * [<v2_unmerged_items>]* |
| 2496 | * [<v2_untracked_items>]* |
| 2497 | * [<v2_ignored_items>]* |
| 2498 | * |
| 2499 | */ |
| 2500 | static void wt_porcelain_v2_print(struct wt_status *s) |
| 2501 | { |
| 2502 | struct wt_status_change_data *d; |
| 2503 | struct string_list_item *it; |
| 2504 | int i; |
| 2505 | |
Jeff Hostetler | d9fc746 | 2016-08-11 10:45:59 -0400 | [diff] [blame] | 2506 | if (s->show_branch) |
| 2507 | wt_porcelain_v2_print_tracking(s); |
| 2508 | |
Øystein Walle | 2e59e78 | 2021-10-22 00:25:32 +0200 | [diff] [blame] | 2509 | if (s->show_stash) |
| 2510 | wt_porcelain_v2_print_stash(s); |
| 2511 | |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2512 | for (i = 0; i < s->change.nr; i++) { |
| 2513 | it = &(s->change.items[i]); |
| 2514 | d = it->util; |
| 2515 | if (!d->stagemask) |
| 2516 | wt_porcelain_v2_print_changed_entry(it, s); |
| 2517 | } |
| 2518 | |
| 2519 | for (i = 0; i < s->change.nr; i++) { |
| 2520 | it = &(s->change.items[i]); |
| 2521 | d = it->util; |
| 2522 | if (d->stagemask) |
| 2523 | wt_porcelain_v2_print_unmerged_entry(it, s); |
| 2524 | } |
| 2525 | |
| 2526 | for (i = 0; i < s->untracked.nr; i++) { |
| 2527 | it = &(s->untracked.items[i]); |
| 2528 | wt_porcelain_v2_print_other(it, s, '?'); |
| 2529 | } |
| 2530 | |
| 2531 | for (i = 0; i < s->ignored.nr; i++) { |
| 2532 | it = &(s->ignored.items[i]); |
| 2533 | wt_porcelain_v2_print_other(it, s, '!'); |
| 2534 | } |
| 2535 | } |
| 2536 | |
Jeff Hostetler | be7e795 | 2016-08-05 18:00:27 -0400 | [diff] [blame] | 2537 | void wt_status_print(struct wt_status *s) |
| 2538 | { |
Jeff Hostetler | 942b274 | 2019-02-22 14:25:03 -0800 | [diff] [blame] | 2539 | trace2_data_intmax("status", s->repo, "count/changed", s->change.nr); |
| 2540 | trace2_data_intmax("status", s->repo, "count/untracked", |
| 2541 | s->untracked.nr); |
| 2542 | trace2_data_intmax("status", s->repo, "count/ignored", s->ignored.nr); |
| 2543 | |
| 2544 | trace2_region_enter("status", "print", s->repo); |
| 2545 | |
Jeff Hostetler | be7e795 | 2016-08-05 18:00:27 -0400 | [diff] [blame] | 2546 | switch (s->status_format) { |
| 2547 | case STATUS_FORMAT_SHORT: |
| 2548 | wt_shortstatus_print(s); |
| 2549 | break; |
| 2550 | case STATUS_FORMAT_PORCELAIN: |
| 2551 | wt_porcelain_print(s); |
| 2552 | break; |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 2553 | case STATUS_FORMAT_PORCELAIN_V2: |
Jeff Hostetler | 24959ba | 2016-08-11 10:45:58 -0400 | [diff] [blame] | 2554 | wt_porcelain_v2_print(s); |
Jeff Hostetler | 1ecdecc | 2016-08-11 10:45:57 -0400 | [diff] [blame] | 2555 | break; |
Jeff Hostetler | be7e795 | 2016-08-05 18:00:27 -0400 | [diff] [blame] | 2556 | case STATUS_FORMAT_UNSPECIFIED: |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 2557 | BUG("finalize_deferred_config() should have been called"); |
Jeff Hostetler | be7e795 | 2016-08-05 18:00:27 -0400 | [diff] [blame] | 2558 | break; |
| 2559 | case STATUS_FORMAT_NONE: |
| 2560 | case STATUS_FORMAT_LONG: |
| 2561 | wt_longstatus_print(s); |
| 2562 | break; |
| 2563 | } |
Jeff Hostetler | 942b274 | 2019-02-22 14:25:03 -0800 | [diff] [blame] | 2564 | |
| 2565 | trace2_region_leave("status", "print", s->repo); |
Jeff Hostetler | be7e795 | 2016-08-05 18:00:27 -0400 | [diff] [blame] | 2566 | } |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2567 | |
| 2568 | /** |
| 2569 | * Returns 1 if there are unstaged changes, 0 otherwise. |
| 2570 | */ |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2571 | int has_unstaged_changes(struct repository *r, int ignore_submodules) |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2572 | { |
| 2573 | struct rev_info rev_info; |
| 2574 | int result; |
| 2575 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2576 | repo_init_revisions(r, &rev_info, NULL); |
Brandon Williams | c6d8ccf | 2017-11-06 14:08:19 -0800 | [diff] [blame] | 2577 | if (ignore_submodules) { |
Brandon Williams | 0d1e0e7 | 2017-10-31 11:19:11 -0700 | [diff] [blame] | 2578 | rev_info.diffopt.flags.ignore_submodules = 1; |
Junio C Hamano | b50d82b | 2017-11-15 12:14:30 +0900 | [diff] [blame] | 2579 | rev_info.diffopt.flags.override_submodule_config = 1; |
Brandon Williams | c6d8ccf | 2017-11-06 14:08:19 -0800 | [diff] [blame] | 2580 | } |
Brandon Williams | 0d1e0e7 | 2017-10-31 11:19:11 -0700 | [diff] [blame] | 2581 | rev_info.diffopt.flags.quick = 1; |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2582 | diff_setup_done(&rev_info.diffopt); |
Jeff King | 25bd3ac | 2023-08-21 16:18:55 -0400 | [diff] [blame] | 2583 | run_diff_files(&rev_info, 0); |
Jeff King | 5cc6b2d | 2023-08-21 16:20:46 -0400 | [diff] [blame] | 2584 | result = diff_result_code(&rev_info.diffopt); |
Ævar Arnfjörð Bjarmason | 1878b5e | 2022-04-13 22:01:35 +0200 | [diff] [blame] | 2585 | release_revisions(&rev_info); |
Ævar Arnfjörð Bjarmason | 54c8a7c | 2022-04-14 07:56:40 +0200 | [diff] [blame] | 2586 | return result; |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2587 | } |
| 2588 | |
| 2589 | /** |
| 2590 | * Returns 1 if there are uncommitted changes, 0 otherwise. |
| 2591 | */ |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2592 | int has_uncommitted_changes(struct repository *r, |
| 2593 | int ignore_submodules) |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2594 | { |
| 2595 | struct rev_info rev_info; |
| 2596 | int result; |
| 2597 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2598 | if (is_index_unborn(r->index)) |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2599 | return 0; |
| 2600 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2601 | repo_init_revisions(r, &rev_info, NULL); |
Johannes Schindelin | d8cc92a | 2016-10-07 18:09:00 +0200 | [diff] [blame] | 2602 | if (ignore_submodules) |
Brandon Williams | 0d1e0e7 | 2017-10-31 11:19:11 -0700 | [diff] [blame] | 2603 | rev_info.diffopt.flags.ignore_submodules = 1; |
| 2604 | rev_info.diffopt.flags.quick = 1; |
Jeff King | 3506dc9 | 2018-07-11 10:14:06 -0400 | [diff] [blame] | 2605 | |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2606 | add_head_to_pending(&rev_info); |
Jeff King | 3506dc9 | 2018-07-11 10:14:06 -0400 | [diff] [blame] | 2607 | if (!rev_info.pending.nr) { |
| 2608 | /* |
| 2609 | * We have no head (or it's corrupt); use the empty tree, |
| 2610 | * which will complain if the index is non-empty. |
| 2611 | */ |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2612 | struct tree *tree = lookup_tree(r, the_hash_algo->empty_tree); |
Jeff King | 3506dc9 | 2018-07-11 10:14:06 -0400 | [diff] [blame] | 2613 | add_pending_object(&rev_info, &tree->object, ""); |
| 2614 | } |
| 2615 | |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2616 | diff_setup_done(&rev_info.diffopt); |
Jeff King | 25bd3ac | 2023-08-21 16:18:55 -0400 | [diff] [blame] | 2617 | run_diff_index(&rev_info, DIFF_INDEX_CACHED); |
Jeff King | 5cc6b2d | 2023-08-21 16:20:46 -0400 | [diff] [blame] | 2618 | result = diff_result_code(&rev_info.diffopt); |
Ævar Arnfjörð Bjarmason | 1878b5e | 2022-04-13 22:01:35 +0200 | [diff] [blame] | 2619 | release_revisions(&rev_info); |
Ævar Arnfjörð Bjarmason | 54c8a7c | 2022-04-14 07:56:40 +0200 | [diff] [blame] | 2620 | return result; |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2621 | } |
| 2622 | |
| 2623 | /** |
| 2624 | * If the work tree has unstaged or uncommitted changes, dies with the |
| 2625 | * appropriate message. |
| 2626 | */ |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2627 | int require_clean_work_tree(struct repository *r, |
| 2628 | const char *action, |
| 2629 | const char *hint, |
| 2630 | int ignore_submodules, |
| 2631 | int gently) |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2632 | { |
Martin Ågren | 837e34e | 2017-10-05 22:32:04 +0200 | [diff] [blame] | 2633 | struct lock_file lock_file = LOCK_INIT; |
Junio C Hamano | 89d38fb | 2016-12-07 11:11:26 -0800 | [diff] [blame] | 2634 | int err = 0, fd; |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2635 | |
Nguyễn Thái Ngọc Duy | 3a95f31 | 2019-01-12 09:13:24 +0700 | [diff] [blame] | 2636 | fd = repo_hold_locked_index(r, &lock_file, 0); |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2637 | refresh_index(r->index, REFRESH_QUIET, NULL, NULL, NULL); |
Junio C Hamano | 89d38fb | 2016-12-07 11:11:26 -0800 | [diff] [blame] | 2638 | if (0 <= fd) |
Nguyễn Thái Ngọc Duy | 1b0d968 | 2019-01-12 09:13:27 +0700 | [diff] [blame] | 2639 | repo_update_index_if_able(r, &lock_file); |
Martin Ågren | 837e34e | 2017-10-05 22:32:04 +0200 | [diff] [blame] | 2640 | rollback_lock_file(&lock_file); |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2641 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2642 | if (has_unstaged_changes(r, ignore_submodules)) { |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2643 | /* TRANSLATORS: the action is e.g. "pull with rebase" */ |
Johannes Schindelin | 4777e17 | 2016-10-07 18:09:04 +0200 | [diff] [blame] | 2644 | error(_("cannot %s: You have unstaged changes."), _(action)); |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2645 | err = 1; |
| 2646 | } |
| 2647 | |
Nguyễn Thái Ngọc Duy | 5b02ca3 | 2018-11-10 06:48:49 +0100 | [diff] [blame] | 2648 | if (has_uncommitted_changes(r, ignore_submodules)) { |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2649 | if (err) |
Johannes Schindelin | 4777e17 | 2016-10-07 18:09:04 +0200 | [diff] [blame] | 2650 | error(_("additionally, your index contains uncommitted changes.")); |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2651 | else |
Johannes Schindelin | 4777e17 | 2016-10-07 18:09:04 +0200 | [diff] [blame] | 2652 | error(_("cannot %s: Your index contains uncommitted changes."), |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2653 | _(action)); |
| 2654 | err = 1; |
| 2655 | } |
| 2656 | |
| 2657 | if (err) { |
Oswald Buddenhagen | a9b5955 | 2023-08-24 17:00:46 +0200 | [diff] [blame] | 2658 | if (hint) { |
| 2659 | if (!*hint) |
| 2660 | BUG("empty hint passed to require_clean_work_tree();" |
| 2661 | " use NULL instead"); |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2662 | error("%s", hint); |
Oswald Buddenhagen | a9b5955 | 2023-08-24 17:00:46 +0200 | [diff] [blame] | 2663 | } |
Johannes Schindelin | fd84986 | 2016-10-07 18:08:38 +0200 | [diff] [blame] | 2664 | if (!gently) |
| 2665 | exit(128); |
| 2666 | } |
| 2667 | |
| 2668 | return err; |
| 2669 | } |