2006-12-19 22:34:12 +00:00
|
|
|
#include "cache.h"
|
2006-09-08 08:05:34 +00:00
|
|
|
#include "wt-status.h"
|
|
|
|
#include "object.h"
|
|
|
|
#include "dir.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "diffcore.h"
|
2008-03-07 02:30:58 +00:00
|
|
|
#include "quote.h"
|
2008-04-12 15:05:32 +00:00
|
|
|
#include "run-command.h"
|
2020-07-28 20:23:39 +00:00
|
|
|
#include "strvec.h"
|
2008-07-02 07:52:16 +00:00
|
|
|
#include "remote.h"
|
2010-05-25 13:45:51 +00:00
|
|
|
#include "refs.h"
|
2010-06-25 14:56:47 +00:00
|
|
|
#include "submodule.h"
|
2012-04-13 10:54:39 +00:00
|
|
|
#include "column.h"
|
2012-06-10 11:17:38 +00:00
|
|
|
#include "strbuf.h"
|
2013-11-05 02:07:29 +00:00
|
|
|
#include "utf8.h"
|
2016-04-22 13:01:31 +00:00
|
|
|
#include "worktree.h"
|
2016-10-07 16:08:38 +00:00
|
|
|
#include "lockfile.h"
|
2019-04-16 10:18:42 +00:00
|
|
|
#include "sequencer.h"
|
2006-09-08 08:05:34 +00:00
|
|
|
|
2019-06-18 20:21:27 +00:00
|
|
|
#define AB_DELAY_WARNING_IN_MS (2 * 1000)
|
|
|
|
|
2014-02-17 12:15:30 +00:00
|
|
|
static const char cut_line[] =
|
2013-12-05 19:44:14 +00:00
|
|
|
"------------------------ >8 ------------------------\n";
|
|
|
|
|
2009-08-10 06:08:40 +00:00
|
|
|
static char default_wt_status_colors[][COLOR_MAXLEN] = {
|
2009-02-13 21:53:40 +00:00
|
|
|
GIT_COLOR_NORMAL, /* WT_STATUS_HEADER */
|
|
|
|
GIT_COLOR_GREEN, /* WT_STATUS_UPDATED */
|
|
|
|
GIT_COLOR_RED, /* WT_STATUS_CHANGED */
|
|
|
|
GIT_COLOR_RED, /* WT_STATUS_UNTRACKED */
|
|
|
|
GIT_COLOR_RED, /* WT_STATUS_NOBRANCH */
|
2009-08-05 07:04:51 +00:00
|
|
|
GIT_COLOR_RED, /* WT_STATUS_UNMERGED */
|
2010-05-25 13:45:51 +00:00
|
|
|
GIT_COLOR_GREEN, /* WT_STATUS_LOCAL_BRANCH */
|
|
|
|
GIT_COLOR_RED, /* WT_STATUS_REMOTE_BRANCH */
|
2010-12-09 17:27:08 +00:00
|
|
|
GIT_COLOR_NIL, /* WT_STATUS_ONBRANCH */
|
2006-09-08 08:05:34 +00:00
|
|
|
};
|
2007-01-11 23:34:41 +00:00
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
static const char *color(int slot, struct wt_status *s)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
color: delay auto-color decision until point of use
When we read a color value either from a config file or from
the command line, we use git_config_colorbool to convert it
from the tristate always/never/auto into a single yes/no
boolean value.
This has some timing implications with respect to starting
a pager.
If we start (or decide not to start) the pager before
checking the colorbool, everything is fine. Either isatty(1)
will give us the right information, or we will properly
check for pager_in_use().
However, if we decide to start a pager after we have checked
the colorbool, things are not so simple. If stdout is a tty,
then we will have already decided to use color. However, the
user may also have configured color.pager not to use color
with the pager. In this case, we need to actually turn off
color. Unfortunately, the pager code has no idea which color
variables were turned on (and there are many of them
throughout the code, and they may even have been manipulated
after the colorbool selection by something like "--color" on
the command line).
This bug can be seen any time a pager is started after
config and command line options are checked. This has
affected "git diff" since 89d07f7 (diff: don't run pager if
user asked for a diff style exit code, 2007-08-12). It has
also affect the log family since 1fda91b (Fix 'git log'
early pager startup error case, 2010-08-24).
This patch splits the notion of parsing a colorbool and
actually checking the configuration. The "use_color"
variables now have an additional possible value,
GIT_COLOR_AUTO. Users of the variable should use the new
"want_color()" wrapper, which will lazily determine and
cache the auto-color decision.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 05:04:23 +00:00
|
|
|
const char *c = "";
|
|
|
|
if (want_color(s->use_color))
|
|
|
|
c = s->color_palette[slot];
|
2010-12-09 17:27:08 +00:00
|
|
|
if (slot == WT_STATUS_ONBRANCH && color_is_nil(c))
|
|
|
|
c = s->color_palette[WT_STATUS_HEADER];
|
|
|
|
return c;
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2011-02-26 05:09:41 +00:00
|
|
|
static void status_vprintf(struct wt_status *s, int at_bol, const char *color,
|
|
|
|
const char *fmt, va_list ap, const char *trail)
|
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
struct strbuf linebuf = STRBUF_INIT;
|
|
|
|
const char *line, *eol;
|
|
|
|
|
|
|
|
strbuf_vaddf(&sb, fmt, ap);
|
|
|
|
if (!sb.len) {
|
2013-09-06 17:43:07 +00:00
|
|
|
if (s->display_comment_prefix) {
|
|
|
|
strbuf_addch(&sb, comment_line_char);
|
|
|
|
if (!trail)
|
|
|
|
strbuf_addch(&sb, ' ');
|
|
|
|
}
|
2011-02-26 05:09:41 +00:00
|
|
|
color_print_strbuf(s->fp, color, &sb);
|
|
|
|
if (trail)
|
|
|
|
fprintf(s->fp, "%s", trail);
|
|
|
|
strbuf_release(&sb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (line = sb.buf; *line; line = eol + 1) {
|
|
|
|
eol = strchr(line, '\n');
|
|
|
|
|
|
|
|
strbuf_reset(&linebuf);
|
2013-09-06 17:43:07 +00:00
|
|
|
if (at_bol && s->display_comment_prefix) {
|
2013-01-16 19:18:48 +00:00
|
|
|
strbuf_addch(&linebuf, comment_line_char);
|
2011-02-26 05:09:41 +00:00
|
|
|
if (*line != '\n' && *line != '\t')
|
|
|
|
strbuf_addch(&linebuf, ' ');
|
|
|
|
}
|
|
|
|
if (eol)
|
|
|
|
strbuf_add(&linebuf, line, eol - line);
|
|
|
|
else
|
|
|
|
strbuf_addstr(&linebuf, line);
|
|
|
|
color_print_strbuf(s->fp, color, &linebuf);
|
|
|
|
if (eol)
|
|
|
|
fprintf(s->fp, "\n");
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
at_bol = 1;
|
|
|
|
}
|
|
|
|
if (trail)
|
|
|
|
fprintf(s->fp, "%s", trail);
|
|
|
|
strbuf_release(&linebuf);
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
void status_printf_ln(struct wt_status *s, const char *color,
|
|
|
|
const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
status_vprintf(s, 1, color, fmt, ap, "\n");
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
void status_printf(struct wt_status *s, const char *color,
|
|
|
|
const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
status_vprintf(s, 1, color, fmt, ap, NULL);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2012-09-16 05:46:26 +00:00
|
|
|
static void status_printf_more(struct wt_status *s, const char *color,
|
|
|
|
const char *fmt, ...)
|
2011-02-26 05:09:41 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
status_vprintf(s, 0, color, fmt, ap, NULL);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
void wt_status_prepare(struct repository *r, struct wt_status *s)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
2007-02-10 00:22:42 +00:00
|
|
|
memset(s, 0, sizeof(*s));
|
2018-11-10 05:48:49 +00:00
|
|
|
s->repo = r;
|
2009-08-10 06:08:40 +00:00
|
|
|
memcpy(s->color_palette, default_wt_status_colors,
|
|
|
|
sizeof(default_wt_status_colors));
|
2009-08-10 04:59:30 +00:00
|
|
|
s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
|
|
|
|
s->use_color = -1;
|
|
|
|
s->relative_paths = 1;
|
2017-10-01 07:29:03 +00:00
|
|
|
s->branch = resolve_refdup("HEAD", 0, NULL, NULL);
|
2006-09-08 08:05:34 +00:00
|
|
|
s->reference = "HEAD";
|
2007-09-18 00:06:42 +00:00
|
|
|
s->fp = stdout;
|
2007-09-18 00:06:43 +00:00
|
|
|
s->index_file = get_index_file();
|
2009-08-05 06:49:33 +00:00
|
|
|
s->change.strdup_strings = 1;
|
2009-08-10 07:36:33 +00:00
|
|
|
s->untracked.strdup_strings = 1;
|
2010-04-10 07:11:53 +00:00
|
|
|
s->ignored.strdup_strings = 1;
|
2013-06-24 18:41:40 +00:00
|
|
|
s->show_branch = -1; /* unspecified */
|
2017-06-17 22:30:51 +00:00
|
|
|
s->show_stash = 0;
|
2018-01-09 18:50:16 +00:00
|
|
|
s->ahead_behind_flags = AHEAD_BEHIND_UNSPECIFIED;
|
2013-09-06 17:43:07 +00:00
|
|
|
s->display_comment_prefix = 0;
|
2018-05-11 15:38:58 +00:00
|
|
|
s->detect_rename = -1;
|
|
|
|
s->rename_score = -1;
|
|
|
|
s->rename_limit = -1;
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_unmerged_header(struct wt_status *s)
|
2009-08-05 07:04:51 +00:00
|
|
|
{
|
2012-06-05 20:21:26 +00:00
|
|
|
int i;
|
|
|
|
int del_mod_conflict = 0;
|
|
|
|
int both_deleted = 0;
|
|
|
|
int not_deleted = 0;
|
2009-08-10 04:59:30 +00:00
|
|
|
const char *c = color(WT_STATUS_HEADER, s);
|
2009-12-12 07:53:41 +00:00
|
|
|
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _("Unmerged paths:"));
|
2012-06-05 20:21:26 +00:00
|
|
|
|
|
|
|
for (i = 0; i < s->change.nr; i++) {
|
|
|
|
struct string_list_item *it = &(s->change.items[i]);
|
|
|
|
struct wt_status_change_data *d = it->util;
|
|
|
|
|
|
|
|
switch (d->stagemask) {
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
both_deleted = 1;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
case 5:
|
|
|
|
del_mod_conflict = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
not_deleted = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-12 10:50:05 +00:00
|
|
|
if (!s->hints)
|
2009-09-09 11:43:03 +00:00
|
|
|
return;
|
2011-02-20 04:12:29 +00:00
|
|
|
if (s->whence != FROM_COMMIT)
|
2009-12-12 07:53:41 +00:00
|
|
|
;
|
2019-04-25 09:45:58 +00:00
|
|
|
else if (!s->is_initial) {
|
|
|
|
if (!strcmp(s->reference, "HEAD"))
|
|
|
|
status_printf_ln(s, c,
|
|
|
|
_(" (use \"git restore --staged <file>...\" to unstage)"));
|
|
|
|
else
|
|
|
|
status_printf_ln(s, c,
|
|
|
|
_(" (use \"git restore --source=%s --staged <file>...\" to unstage)"),
|
|
|
|
s->reference);
|
|
|
|
} else
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _(" (use \"git rm --cached <file>...\" to unstage)"));
|
2012-06-05 20:21:26 +00:00
|
|
|
|
|
|
|
if (!both_deleted) {
|
|
|
|
if (!del_mod_conflict)
|
|
|
|
status_printf_ln(s, c, _(" (use \"git add <file>...\" to mark resolution)"));
|
|
|
|
else
|
|
|
|
status_printf_ln(s, c, _(" (use \"git add/rm <file>...\" as appropriate to mark resolution)"));
|
|
|
|
} else if (!del_mod_conflict && !not_deleted) {
|
|
|
|
status_printf_ln(s, c, _(" (use \"git rm <file>...\" to mark resolution)"));
|
|
|
|
} else {
|
|
|
|
status_printf_ln(s, c, _(" (use \"git add/rm <file>...\" as appropriate to mark resolution)"));
|
|
|
|
}
|
2009-08-05 07:04:51 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_cached_header(struct wt_status *s)
|
2007-01-02 19:26:21 +00:00
|
|
|
{
|
2009-08-10 04:59:30 +00:00
|
|
|
const char *c = color(WT_STATUS_HEADER, s);
|
2009-12-12 07:53:41 +00:00
|
|
|
|
2011-02-22 23:42:16 +00:00
|
|
|
status_printf_ln(s, c, _("Changes to be committed:"));
|
2013-09-12 10:50:05 +00:00
|
|
|
if (!s->hints)
|
2009-09-09 11:43:03 +00:00
|
|
|
return;
|
2011-02-20 04:12:29 +00:00
|
|
|
if (s->whence != FROM_COMMIT)
|
2009-12-12 07:53:41 +00:00
|
|
|
; /* NEEDSWORK: use "git reset --unresolve"??? */
|
2019-04-25 09:45:58 +00:00
|
|
|
else if (!s->is_initial) {
|
|
|
|
if (!strcmp(s->reference, "HEAD"))
|
|
|
|
status_printf_ln(s, c
|
|
|
|
, _(" (use \"git restore --staged <file>...\" to unstage)"));
|
|
|
|
else
|
|
|
|
status_printf_ln(s, c,
|
|
|
|
_(" (use \"git restore --source=%s --staged <file>...\" to unstage)"),
|
|
|
|
s->reference);
|
|
|
|
} else
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _(" (use \"git rm --cached <file>...\" to unstage)"));
|
2007-01-02 19:26:21 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_dirty_header(struct wt_status *s,
|
|
|
|
int has_deleted,
|
|
|
|
int has_dirty_submodules)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
2009-08-10 04:59:30 +00:00
|
|
|
const char *c = color(WT_STATUS_HEADER, s);
|
2009-12-12 07:53:41 +00:00
|
|
|
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _("Changes not staged for commit:"));
|
2013-09-12 10:50:05 +00:00
|
|
|
if (!s->hints)
|
2009-09-09 11:43:03 +00:00
|
|
|
return;
|
2008-09-07 22:05:02 +00:00
|
|
|
if (!has_deleted)
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _(" (use \"git add <file>...\" to update what will be committed)"));
|
2008-09-07 22:05:02 +00:00
|
|
|
else
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _(" (use \"git add/rm <file>...\" to update what will be committed)"));
|
2019-04-25 09:45:58 +00:00
|
|
|
status_printf_ln(s, c, _(" (use \"git restore <file>...\" to discard changes in working directory)"));
|
2010-03-08 12:53:19 +00:00
|
|
|
if (has_dirty_submodules)
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _(" (commit or discard the untracked or modified content in submodules)"));
|
2008-09-07 22:05:02 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_other_header(struct wt_status *s,
|
|
|
|
const char *what,
|
|
|
|
const char *how)
|
2008-09-07 22:05:02 +00:00
|
|
|
{
|
2009-08-10 04:59:30 +00:00
|
|
|
const char *c = color(WT_STATUS_HEADER, s);
|
2012-09-06 15:16:50 +00:00
|
|
|
status_printf_ln(s, c, "%s:", what);
|
2013-09-12 10:50:05 +00:00
|
|
|
if (!s->hints)
|
2009-09-09 11:43:03 +00:00
|
|
|
return;
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _(" (use \"git %s <file>...\" to include in what will be committed)"), how);
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_trailer(struct wt_status *s)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf_ln(s, color(WT_STATUS_HEADER, s), "%s", "");
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2013-12-19 19:43:19 +00:00
|
|
|
static const char *wt_status_unmerged_status_string(int stagemask)
|
2009-08-05 07:04:51 +00:00
|
|
|
{
|
2013-12-19 19:43:19 +00:00
|
|
|
switch (stagemask) {
|
|
|
|
case 1:
|
|
|
|
return _("both deleted:");
|
|
|
|
case 2:
|
|
|
|
return _("added by us:");
|
|
|
|
case 3:
|
|
|
|
return _("deleted by them:");
|
|
|
|
case 4:
|
|
|
|
return _("added by them:");
|
|
|
|
case 5:
|
|
|
|
return _("deleted by us:");
|
|
|
|
case 6:
|
|
|
|
return _("both added:");
|
|
|
|
case 7:
|
|
|
|
return _("both modified:");
|
|
|
|
default:
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("unhandled unmerged status %x", stagemask);
|
2009-08-05 07:04:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-05 02:07:29 +00:00
|
|
|
static const char *wt_status_diff_status_string(int status)
|
|
|
|
{
|
|
|
|
switch (status) {
|
|
|
|
case DIFF_STATUS_ADDED:
|
2014-03-12 20:51:22 +00:00
|
|
|
return _("new file:");
|
2013-11-05 02:07:29 +00:00
|
|
|
case DIFF_STATUS_COPIED:
|
2014-03-12 20:51:22 +00:00
|
|
|
return _("copied:");
|
2013-11-05 02:07:29 +00:00
|
|
|
case DIFF_STATUS_DELETED:
|
2014-03-12 20:51:22 +00:00
|
|
|
return _("deleted:");
|
2013-11-05 02:07:29 +00:00
|
|
|
case DIFF_STATUS_MODIFIED:
|
2014-03-12 20:51:22 +00:00
|
|
|
return _("modified:");
|
2013-11-05 02:07:29 +00:00
|
|
|
case DIFF_STATUS_RENAMED:
|
2014-03-12 20:51:22 +00:00
|
|
|
return _("renamed:");
|
2013-11-05 02:07:29 +00:00
|
|
|
case DIFF_STATUS_TYPE_CHANGED:
|
2014-03-12 20:51:22 +00:00
|
|
|
return _("typechange:");
|
2013-11-05 02:07:29 +00:00
|
|
|
case DIFF_STATUS_UNKNOWN:
|
2014-03-12 20:51:22 +00:00
|
|
|
return _("unknown:");
|
2013-11-05 02:07:29 +00:00
|
|
|
case DIFF_STATUS_UNMERGED:
|
2014-03-12 20:51:22 +00:00
|
|
|
return _("unmerged:");
|
2013-11-05 02:07:29 +00:00
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-19 19:43:19 +00:00
|
|
|
static int maxwidth(const char *(*label)(int), int minval, int maxval)
|
|
|
|
{
|
|
|
|
int result = 0, i;
|
|
|
|
|
|
|
|
for (i = minval; i <= maxval; i++) {
|
|
|
|
const char *s = label(i);
|
|
|
|
int len = s ? utf8_strwidth(s) : 0;
|
|
|
|
if (len > result)
|
|
|
|
result = len;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_unmerged_data(struct wt_status *s,
|
|
|
|
struct string_list_item *it)
|
2013-12-19 19:43:19 +00:00
|
|
|
{
|
|
|
|
const char *c = color(WT_STATUS_UNMERGED, s);
|
|
|
|
struct wt_status_change_data *d = it->util;
|
|
|
|
struct strbuf onebuf = STRBUF_INIT;
|
|
|
|
static char *padding;
|
|
|
|
static int label_width;
|
|
|
|
const char *one, *how;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!padding) {
|
|
|
|
label_width = maxwidth(wt_status_unmerged_status_string, 1, 7);
|
|
|
|
label_width += strlen(" ");
|
|
|
|
padding = xmallocz(label_width);
|
|
|
|
memset(padding, ' ', label_width);
|
|
|
|
}
|
|
|
|
|
2020-09-10 17:01:54 +00:00
|
|
|
one = quote_path(it->string, s->prefix, &onebuf, 0);
|
2013-12-19 19:43:19 +00:00
|
|
|
status_printf(s, color(WT_STATUS_HEADER, s), "\t");
|
|
|
|
|
|
|
|
how = wt_status_unmerged_status_string(d->stagemask);
|
|
|
|
len = label_width - utf8_strwidth(how);
|
|
|
|
status_printf_more(s, c, "%s%.*s%s\n", how, len, padding, one);
|
|
|
|
strbuf_release(&onebuf);
|
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_change_data(struct wt_status *s,
|
|
|
|
int change_type,
|
|
|
|
struct string_list_item *it)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
2009-08-05 06:49:33 +00:00
|
|
|
struct wt_status_change_data *d = it->util;
|
2009-08-10 04:59:30 +00:00
|
|
|
const char *c = color(change_type, s);
|
wt-status: fix possible use of uninitialized variable
In wt_status_print_change_data, we accept a change_type flag
that is meant to be either WT_STATUS_UPDATED or
WT_STATUS_CHANGED. We then switch() on this value to set
the local variable "status" for each case, but do not
provide a fallback "default" label to the switch statement.
As a result, the compiler realizes that "status" might be
unset, and complains with a warning. To silence this
warning, we use the "int status = status" trick. This is
correct with the current code, as all callers provide one of
the two expected change_type flags. However, it's also a
maintenance trap, as there is nothing to prevent future
callers from passing another flag, nor to document this
assumption.
Instead of using the "x = x" hack, let's handle the default
case in the switch() statement with a die("BUG"). That tells
the compiler and any readers of the code exactly what the
function's input assumptions are.
We could also convert the flag to an enum, which would
provide a compile-time check on the function input. However,
since these flags are part of a larger enum, that would make
the code unnecessarily complex (we would have to make a new
enum with just the two flags, and then convert it to the old
enum for passing to sub-functions).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-21 11:05:28 +00:00
|
|
|
int status;
|
2009-08-05 06:49:33 +00:00
|
|
|
char *one_name;
|
|
|
|
char *two_name;
|
2006-11-08 21:20:46 +00:00
|
|
|
const char *one, *two;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf onebuf = STRBUF_INIT, twobuf = STRBUF_INIT;
|
2010-03-08 12:53:19 +00:00
|
|
|
struct strbuf extra = STRBUF_INIT;
|
2013-11-05 02:07:29 +00:00
|
|
|
static char *padding;
|
2014-03-12 20:51:22 +00:00
|
|
|
static int label_width;
|
2013-11-05 02:07:29 +00:00
|
|
|
const char *what;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!padding) {
|
2013-12-19 19:43:19 +00:00
|
|
|
/* If DIFF_STATUS_* uses outside the range [A..Z], we're in trouble */
|
|
|
|
label_width = maxwidth(wt_status_diff_status_string, 'A', 'Z');
|
2014-03-12 20:51:22 +00:00
|
|
|
label_width += strlen(" ");
|
|
|
|
padding = xmallocz(label_width);
|
|
|
|
memset(padding, ' ', label_width);
|
2013-11-05 02:07:29 +00:00
|
|
|
}
|
2006-11-08 21:20:46 +00:00
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
one_name = two_name = it->string;
|
|
|
|
switch (change_type) {
|
|
|
|
case WT_STATUS_UPDATED:
|
|
|
|
status = d->index_status;
|
|
|
|
break;
|
|
|
|
case WT_STATUS_CHANGED:
|
2010-03-08 12:53:19 +00:00
|
|
|
if (d->new_submodule_commits || d->dirty_submodule) {
|
|
|
|
strbuf_addstr(&extra, " (");
|
|
|
|
if (d->new_submodule_commits)
|
2016-09-15 18:31:00 +00:00
|
|
|
strbuf_addstr(&extra, _("new commits, "));
|
2010-03-08 12:53:19 +00:00
|
|
|
if (d->dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
|
2016-09-15 18:31:00 +00:00
|
|
|
strbuf_addstr(&extra, _("modified content, "));
|
2010-03-08 12:53:19 +00:00
|
|
|
if (d->dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
|
2016-09-15 18:31:00 +00:00
|
|
|
strbuf_addstr(&extra, _("untracked content, "));
|
2010-03-08 12:53:19 +00:00
|
|
|
strbuf_setlen(&extra, extra.len - 2);
|
|
|
|
strbuf_addch(&extra, ')');
|
|
|
|
}
|
2009-08-05 06:49:33 +00:00
|
|
|
status = d->worktree_status;
|
|
|
|
break;
|
wt-status: fix possible use of uninitialized variable
In wt_status_print_change_data, we accept a change_type flag
that is meant to be either WT_STATUS_UPDATED or
WT_STATUS_CHANGED. We then switch() on this value to set
the local variable "status" for each case, but do not
provide a fallback "default" label to the switch statement.
As a result, the compiler realizes that "status" might be
unset, and complains with a warning. To silence this
warning, we use the "int status = status" trick. This is
correct with the current code, as all callers provide one of
the two expected change_type flags. However, it's also a
maintenance trap, as there is nothing to prevent future
callers from passing another flag, nor to document this
assumption.
Instead of using the "x = x" hack, let's handle the default
case in the switch() statement with a die("BUG"). That tells
the compiler and any readers of the code exactly what the
function's input assumptions are.
We could also convert the flag to an enum, which would
provide a compile-time check on the function input. However,
since these flags are part of a larger enum, that would make
the code unnecessarily complex (we would have to make a new
enum with just the two flags, and then convert it to the old
enum for passing to sub-functions).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-21 11:05:28 +00:00
|
|
|
default:
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("unhandled change_type %d in wt_longstatus_print_change_data",
|
wt-status: fix possible use of uninitialized variable
In wt_status_print_change_data, we accept a change_type flag
that is meant to be either WT_STATUS_UPDATED or
WT_STATUS_CHANGED. We then switch() on this value to set
the local variable "status" for each case, but do not
provide a fallback "default" label to the switch statement.
As a result, the compiler realizes that "status" might be
unset, and complains with a warning. To silence this
warning, we use the "int status = status" trick. This is
correct with the current code, as all callers provide one of
the two expected change_type flags. However, it's also a
maintenance trap, as there is nothing to prevent future
callers from passing another flag, nor to document this
assumption.
Instead of using the "x = x" hack, let's handle the default
case in the switch() statement with a die("BUG"). That tells
the compiler and any readers of the code exactly what the
function's input assumptions are.
We could also convert the flag to an enum, which would
provide a compile-time check on the function input. However,
since these flags are part of a larger enum, that would make
the code unnecessarily complex (we would have to make a new
enum with just the two flags, and then convert it to the old
enum for passing to sub-functions).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-21 11:05:28 +00:00
|
|
|
change_type);
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
|
|
|
|
2017-12-27 10:18:39 +00:00
|
|
|
/*
|
|
|
|
* Only pick up the rename it's relevant. If the rename is for
|
|
|
|
* the changed section and we're printing the updated section,
|
|
|
|
* ignore it.
|
|
|
|
*/
|
|
|
|
if (d->rename_status == status)
|
|
|
|
one_name = d->rename_source;
|
|
|
|
|
2020-09-10 17:01:54 +00:00
|
|
|
one = quote_path(one_name, s->prefix, &onebuf, 0);
|
|
|
|
two = quote_path(two_name, s->prefix, &twobuf, 0);
|
2006-11-08 21:20:46 +00:00
|
|
|
|
2011-02-26 05:11:37 +00:00
|
|
|
status_printf(s, color(WT_STATUS_HEADER, s), "\t");
|
2013-11-05 02:07:29 +00:00
|
|
|
what = wt_status_diff_status_string(status);
|
|
|
|
if (!what)
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("unhandled diff status %c", status);
|
2014-03-12 20:51:22 +00:00
|
|
|
len = label_width - utf8_strwidth(what);
|
2013-11-05 02:07:29 +00:00
|
|
|
assert(len >= 0);
|
2017-12-27 10:18:38 +00:00
|
|
|
if (one_name != two_name)
|
2014-03-12 20:51:22 +00:00
|
|
|
status_printf_more(s, c, "%s%.*s%s -> %s",
|
2013-11-05 02:07:29 +00:00
|
|
|
what, len, padding, one, two);
|
|
|
|
else
|
2014-03-12 20:51:22 +00:00
|
|
|
status_printf_more(s, c, "%s%.*s%s",
|
2013-11-05 02:07:29 +00:00
|
|
|
what, len, padding, one);
|
2010-03-08 12:53:19 +00:00
|
|
|
if (extra.len) {
|
2011-02-26 05:11:37 +00:00
|
|
|
status_printf_more(s, color(WT_STATUS_HEADER, s), "%s", extra.buf);
|
2010-03-08 12:53:19 +00:00
|
|
|
strbuf_release(&extra);
|
|
|
|
}
|
2011-02-26 05:11:37 +00:00
|
|
|
status_printf_more(s, GIT_COLOR_NORMAL, "\n");
|
2007-11-11 17:35:41 +00:00
|
|
|
strbuf_release(&onebuf);
|
|
|
|
strbuf_release(&twobuf);
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2017-12-27 10:18:36 +00:00
|
|
|
static char short_submodule_status(struct wt_status_change_data *d)
|
|
|
|
{
|
short status: improve reporting for submodule changes
If I add an untracked file to a submodule or modify a tracked file,
currently "git status --short" treats the change in the same way as
changes to the current HEAD of the submodule:
$ git clone --quiet --recurse-submodules https://gerrit.googlesource.com/gerrit
$ echo hello >gerrit/plugins/replication/stray-file
$ sed -i -e 's/.*//' gerrit/plugins/replication/.mailmap
$ git -C gerrit status --short
M plugins/replication
This is by analogy with ordinary files, where "M" represents a change
that has not been added yet to the index. But this change cannot be
added to the index without entering the submodule, "git add"-ing it,
and running "git commit", so the analogy is counterproductive.
Introduce new status letters " ?" and " m" for this. These are similar
to the existing "??" and " M" but mean that the submodule (not the
parent project) has new untracked files and modified files, respectively.
The user can use "git add" and "git commit" from within the submodule to
add them.
Changes to the submodule's HEAD commit can be recorded in the index with
a plain "git add -u" and are shown with " M", like today.
To avoid excessive clutter, show at most one of " ?", " m", and " M" for
the submodule. They represent increasing levels of change --- the last
one that applies is shown (e.g., " m" if there are both modified files
and untracked files in the submodule, or " M" if the submodule's HEAD
has been modified and it has untracked files).
While making these changes, we need to make sure to not break porcelain
level 1, which shares code with "status --short". We only change
"git status --short".
Non-short "git status" and "git status --porcelain=2" already handle
these cases by showing more detail:
$ git -C gerrit status --porcelain=2
1 .M S.MU 160000 160000 160000 305c864db28eb0c77c8499bc04c87de3f849cf3c 305c864db28eb0c77c8499bc04c87de3f849cf3c plugins/replication
$ git -C gerrit status
[...]
modified: plugins/replication (modified content, untracked content)
Scripts caring about these distinctions should use --porcelain=2.
Helped-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-29 22:26:15 +00:00
|
|
|
if (d->new_submodule_commits)
|
|
|
|
return 'M';
|
|
|
|
if (d->dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
|
|
|
|
return 'm';
|
|
|
|
if (d->dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
|
|
|
|
return '?';
|
|
|
|
return d->worktree_status;
|
|
|
|
}
|
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
static void wt_status_collect_changed_cb(struct diff_queue_struct *q,
|
|
|
|
struct diff_options *options,
|
|
|
|
void *data)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
|
|
|
struct wt_status *s = data;
|
|
|
|
int i;
|
2009-08-05 06:49:33 +00:00
|
|
|
|
|
|
|
if (!q->nr)
|
|
|
|
return;
|
|
|
|
s->workdir_dirty = 1;
|
2006-09-08 08:05:34 +00:00
|
|
|
for (i = 0; i < q->nr; i++) {
|
2009-08-05 06:49:33 +00:00
|
|
|
struct diff_filepair *p;
|
|
|
|
struct string_list_item *it;
|
|
|
|
struct wt_status_change_data *d;
|
|
|
|
|
|
|
|
p = q->queue[i];
|
2017-12-27 10:18:39 +00:00
|
|
|
it = string_list_insert(&s->change, p->two->path);
|
2009-08-05 06:49:33 +00:00
|
|
|
d = it->util;
|
|
|
|
if (!d) {
|
2021-03-13 16:17:22 +00:00
|
|
|
CALLOC_ARRAY(d, 1);
|
2009-08-05 06:49:33 +00:00
|
|
|
it->util = d;
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
2009-08-05 06:49:33 +00:00
|
|
|
if (!d->worktree_status)
|
|
|
|
d->worktree_status = p->status;
|
short status: improve reporting for submodule changes
If I add an untracked file to a submodule or modify a tracked file,
currently "git status --short" treats the change in the same way as
changes to the current HEAD of the submodule:
$ git clone --quiet --recurse-submodules https://gerrit.googlesource.com/gerrit
$ echo hello >gerrit/plugins/replication/stray-file
$ sed -i -e 's/.*//' gerrit/plugins/replication/.mailmap
$ git -C gerrit status --short
M plugins/replication
This is by analogy with ordinary files, where "M" represents a change
that has not been added yet to the index. But this change cannot be
added to the index without entering the submodule, "git add"-ing it,
and running "git commit", so the analogy is counterproductive.
Introduce new status letters " ?" and " m" for this. These are similar
to the existing "??" and " M" but mean that the submodule (not the
parent project) has new untracked files and modified files, respectively.
The user can use "git add" and "git commit" from within the submodule to
add them.
Changes to the submodule's HEAD commit can be recorded in the index with
a plain "git add -u" and are shown with " M", like today.
To avoid excessive clutter, show at most one of " ?", " m", and " M" for
the submodule. They represent increasing levels of change --- the last
one that applies is shown (e.g., " m" if there are both modified files
and untracked files in the submodule, or " M" if the submodule's HEAD
has been modified and it has untracked files).
While making these changes, we need to make sure to not break porcelain
level 1, which shares code with "status --short". We only change
"git status --short".
Non-short "git status" and "git status --porcelain=2" already handle
these cases by showing more detail:
$ git -C gerrit status --porcelain=2
1 .M S.MU 160000 160000 160000 305c864db28eb0c77c8499bc04c87de3f849cf3c 305c864db28eb0c77c8499bc04c87de3f849cf3c plugins/replication
$ git -C gerrit status
[...]
modified: plugins/replication (modified content, untracked content)
Scripts caring about these distinctions should use --porcelain=2.
Helped-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-29 22:26:15 +00:00
|
|
|
if (S_ISGITLINK(p->two->mode)) {
|
|
|
|
d->dirty_submodule = p->two->dirty_submodule;
|
convert "oidcmp() == 0" to oideq()
Using the more restrictive oideq() should, in the long run,
give the compiler more opportunities to optimize these
callsites. For now, this conversion should be a complete
noop with respect to the generated code.
The result is also perhaps a little more readable, as it
avoids the "zero is equal" idiom. Since it's so prevalent in
C, I think seasoned programmers tend not to even notice it
anymore, but it can sometimes make for awkward double
negations (e.g., we can drop a few !!oidcmp() instances
here).
This patch was generated almost entirely by the included
coccinelle patch. This mechanical conversion should be
completely safe, because we check explicitly for cases where
oidcmp() is compared to 0, which is what oideq() is doing
under the hood. Note that we don't have to catch "!oidcmp()"
separately; coccinelle's standard isomorphisms make sure the
two are treated equivalently.
I say "almost" because I did hand-edit the coccinelle output
to fix up a few style violations (it mostly keeps the
original formatting, but sometimes unwraps long lines).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-28 21:22:40 +00:00
|
|
|
d->new_submodule_commits = !oideq(&p->one->oid,
|
|
|
|
&p->two->oid);
|
short status: improve reporting for submodule changes
If I add an untracked file to a submodule or modify a tracked file,
currently "git status --short" treats the change in the same way as
changes to the current HEAD of the submodule:
$ git clone --quiet --recurse-submodules https://gerrit.googlesource.com/gerrit
$ echo hello >gerrit/plugins/replication/stray-file
$ sed -i -e 's/.*//' gerrit/plugins/replication/.mailmap
$ git -C gerrit status --short
M plugins/replication
This is by analogy with ordinary files, where "M" represents a change
that has not been added yet to the index. But this change cannot be
added to the index without entering the submodule, "git add"-ing it,
and running "git commit", so the analogy is counterproductive.
Introduce new status letters " ?" and " m" for this. These are similar
to the existing "??" and " M" but mean that the submodule (not the
parent project) has new untracked files and modified files, respectively.
The user can use "git add" and "git commit" from within the submodule to
add them.
Changes to the submodule's HEAD commit can be recorded in the index with
a plain "git add -u" and are shown with " M", like today.
To avoid excessive clutter, show at most one of " ?", " m", and " M" for
the submodule. They represent increasing levels of change --- the last
one that applies is shown (e.g., " m" if there are both modified files
and untracked files in the submodule, or " M" if the submodule's HEAD
has been modified and it has untracked files).
While making these changes, we need to make sure to not break porcelain
level 1, which shares code with "status --short". We only change
"git status --short".
Non-short "git status" and "git status --porcelain=2" already handle
these cases by showing more detail:
$ git -C gerrit status --porcelain=2
1 .M S.MU 160000 160000 160000 305c864db28eb0c77c8499bc04c87de3f849cf3c 305c864db28eb0c77c8499bc04c87de3f849cf3c plugins/replication
$ git -C gerrit status
[...]
modified: plugins/replication (modified content, untracked content)
Scripts caring about these distinctions should use --porcelain=2.
Helped-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-29 22:26:15 +00:00
|
|
|
if (s->status_format == STATUS_FORMAT_SHORT)
|
|
|
|
d->worktree_status = short_submodule_status(d);
|
|
|
|
}
|
2016-08-11 14:45:57 +00:00
|
|
|
|
|
|
|
switch (p->status) {
|
|
|
|
case DIFF_STATUS_ADDED:
|
2016-10-24 10:42:19 +00:00
|
|
|
d->mode_worktree = p->two->mode;
|
2016-08-11 14:45:57 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DIFF_STATUS_DELETED:
|
|
|
|
d->mode_index = p->one->mode;
|
|
|
|
oidcpy(&d->oid_index, &p->one->oid);
|
|
|
|
/* mode_worktree is zero for a delete. */
|
|
|
|
break;
|
|
|
|
|
2017-12-27 10:18:39 +00:00
|
|
|
case DIFF_STATUS_COPIED:
|
|
|
|
case DIFF_STATUS_RENAMED:
|
|
|
|
if (d->rename_status)
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("multiple renames on the same target? how?");
|
2017-12-27 10:18:39 +00:00
|
|
|
d->rename_source = xstrdup(p->one->path);
|
|
|
|
d->rename_score = p->score * 100 / MAX_SCORE;
|
|
|
|
d->rename_status = p->status;
|
|
|
|
/* fallthru */
|
2016-08-11 14:45:57 +00:00
|
|
|
case DIFF_STATUS_MODIFIED:
|
|
|
|
case DIFF_STATUS_TYPE_CHANGED:
|
|
|
|
case DIFF_STATUS_UNMERGED:
|
|
|
|
d->mode_index = p->one->mode;
|
|
|
|
d->mode_worktree = p->two->mode;
|
|
|
|
oidcpy(&d->oid_index, &p->one->oid);
|
|
|
|
break;
|
|
|
|
|
2017-12-27 10:18:37 +00:00
|
|
|
default:
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("unhandled diff-files status '%c'", p->status);
|
2016-08-11 14:45:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
static int unmerged_mask(struct index_state *istate, const char *path)
|
2009-08-05 07:04:51 +00:00
|
|
|
{
|
|
|
|
int pos, mask;
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 15:29:00 +00:00
|
|
|
const struct cache_entry *ce;
|
2009-08-05 07:04:51 +00:00
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
pos = index_name_pos(istate, path, strlen(path));
|
2009-08-05 07:04:51 +00:00
|
|
|
if (0 <= pos)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
mask = 0;
|
|
|
|
pos = -pos-1;
|
2018-11-10 05:48:49 +00:00
|
|
|
while (pos < istate->cache_nr) {
|
|
|
|
ce = istate->cache[pos++];
|
2009-08-05 07:04:51 +00:00
|
|
|
if (strcmp(ce->name, path) || !ce_stage(ce))
|
|
|
|
break;
|
|
|
|
mask |= (1 << (ce_stage(ce) - 1));
|
|
|
|
}
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
static void wt_status_collect_updated_cb(struct diff_queue_struct *q,
|
|
|
|
struct diff_options *options,
|
|
|
|
void *data)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
2007-01-02 19:26:22 +00:00
|
|
|
struct wt_status *s = data;
|
2006-09-08 08:05:34 +00:00
|
|
|
int i;
|
2009-08-05 06:49:33 +00:00
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p;
|
|
|
|
struct string_list_item *it;
|
|
|
|
struct wt_status_change_data *d;
|
|
|
|
|
|
|
|
p = q->queue[i];
|
2010-06-25 23:41:35 +00:00
|
|
|
it = string_list_insert(&s->change, p->two->path);
|
2009-08-05 06:49:33 +00:00
|
|
|
d = it->util;
|
|
|
|
if (!d) {
|
2021-03-13 16:17:22 +00:00
|
|
|
CALLOC_ARRAY(d, 1);
|
2009-08-05 06:49:33 +00:00
|
|
|
it->util = d;
|
|
|
|
}
|
|
|
|
if (!d->index_status)
|
|
|
|
d->index_status = p->status;
|
|
|
|
switch (p->status) {
|
2016-08-11 14:45:57 +00:00
|
|
|
case DIFF_STATUS_ADDED:
|
|
|
|
/* Leave {mode,oid}_head zero for an add. */
|
|
|
|
d->mode_index = p->two->mode;
|
|
|
|
oidcpy(&d->oid_index, &p->two->oid);
|
2018-09-06 00:53:29 +00:00
|
|
|
s->committable = 1;
|
2016-08-11 14:45:57 +00:00
|
|
|
break;
|
|
|
|
case DIFF_STATUS_DELETED:
|
|
|
|
d->mode_head = p->one->mode;
|
|
|
|
oidcpy(&d->oid_head, &p->one->oid);
|
2018-09-06 00:53:29 +00:00
|
|
|
s->committable = 1;
|
2016-08-11 14:45:57 +00:00
|
|
|
/* Leave {mode,oid}_index zero for a delete. */
|
|
|
|
break;
|
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
case DIFF_STATUS_COPIED:
|
|
|
|
case DIFF_STATUS_RENAMED:
|
2017-12-27 10:18:39 +00:00
|
|
|
if (d->rename_status)
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("multiple renames on the same target? how?");
|
2017-12-27 10:18:38 +00:00
|
|
|
d->rename_source = xstrdup(p->one->path);
|
|
|
|
d->rename_score = p->score * 100 / MAX_SCORE;
|
|
|
|
d->rename_status = p->status;
|
2016-08-11 14:45:57 +00:00
|
|
|
/* fallthru */
|
|
|
|
case DIFF_STATUS_MODIFIED:
|
|
|
|
case DIFF_STATUS_TYPE_CHANGED:
|
|
|
|
d->mode_head = p->one->mode;
|
|
|
|
d->mode_index = p->two->mode;
|
|
|
|
oidcpy(&d->oid_head, &p->one->oid);
|
|
|
|
oidcpy(&d->oid_index, &p->two->oid);
|
2018-09-06 00:53:29 +00:00
|
|
|
s->committable = 1;
|
2009-08-05 06:49:33 +00:00
|
|
|
break;
|
2009-08-05 07:04:51 +00:00
|
|
|
case DIFF_STATUS_UNMERGED:
|
2018-11-10 05:48:49 +00:00
|
|
|
d->stagemask = unmerged_mask(s->repo->index,
|
|
|
|
p->two->path);
|
2016-08-11 14:45:57 +00:00
|
|
|
/*
|
|
|
|
* Don't bother setting {mode,oid}_{head,index} since the print
|
|
|
|
* code will output the stage values directly and not use the
|
|
|
|
* values in these fields.
|
|
|
|
*/
|
2009-08-05 07:04:51 +00:00
|
|
|
break;
|
2017-12-27 10:18:37 +00:00
|
|
|
|
|
|
|
default:
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("unhandled diff-index status '%c'", p->status);
|
2017-12-27 10:18:37 +00:00
|
|
|
break;
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
2007-01-02 19:26:22 +00:00
|
|
|
}
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
static void wt_status_collect_changes_worktree(struct wt_status *s)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
2009-08-05 06:49:33 +00:00
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
repo_init_revisions(s->repo, &rev, NULL);
|
2009-08-05 06:49:33 +00:00
|
|
|
setup_revisions(0, NULL, &rev, NULL);
|
|
|
|
rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
|
2017-10-31 18:19:11 +00:00
|
|
|
rev.diffopt.flags.dirty_submodules = 1;
|
2016-10-24 10:42:19 +00:00
|
|
|
rev.diffopt.ita_invisible_in_index = 1;
|
2010-03-13 22:00:27 +00:00
|
|
|
if (!s->show_untracked_files)
|
2017-10-31 18:19:11 +00:00
|
|
|
rev.diffopt.flags.ignore_untracked_in_submodules = 1;
|
2010-08-05 22:39:25 +00:00
|
|
|
if (s->ignore_submodule_arg) {
|
2017-10-31 18:19:11 +00:00
|
|
|
rev.diffopt.flags.override_submodule_config = 1;
|
2010-06-25 14:56:47 +00:00
|
|
|
handle_ignore_submodules_arg(&rev.diffopt, s->ignore_submodule_arg);
|
2020-11-10 08:39:00 +00:00
|
|
|
} else if (!rev.diffopt.flags.ignore_submodule_set &&
|
|
|
|
s->show_untracked_files != SHOW_NO_UNTRACKED_FILES)
|
|
|
|
handle_ignore_submodules_arg(&rev.diffopt, "none");
|
2009-08-05 06:49:33 +00:00
|
|
|
rev.diffopt.format_callback = wt_status_collect_changed_cb;
|
|
|
|
rev.diffopt.format_callback_data = s;
|
2018-05-11 15:38:58 +00:00
|
|
|
rev.diffopt.detect_rename = s->detect_rename >= 0 ? s->detect_rename : rev.diffopt.detect_rename;
|
|
|
|
rev.diffopt.rename_limit = s->rename_limit >= 0 ? s->rename_limit : rev.diffopt.rename_limit;
|
|
|
|
rev.diffopt.rename_score = s->rename_score >= 0 ? s->rename_score : rev.diffopt.rename_score;
|
2013-07-14 08:35:39 +00:00
|
|
|
copy_pathspec(&rev.prune_data, &s->pathspec);
|
2009-08-05 06:49:33 +00:00
|
|
|
run_diff_files(&rev, 0);
|
2022-04-13 20:01:44 +00:00
|
|
|
release_revisions(&rev);
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void wt_status_collect_changes_index(struct wt_status *s)
|
|
|
|
{
|
|
|
|
struct rev_info rev;
|
2010-03-09 06:58:09 +00:00
|
|
|
struct setup_revision_opt opt;
|
2009-08-05 06:49:33 +00:00
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
repo_init_revisions(s->repo, &rev, NULL);
|
2010-03-09 06:58:09 +00:00
|
|
|
memset(&opt, 0, sizeof(opt));
|
2018-05-02 00:26:00 +00:00
|
|
|
opt.def = s->is_initial ? empty_tree_oid_hex() : s->reference;
|
2010-03-09 06:58:09 +00:00
|
|
|
setup_revisions(0, NULL, &rev, &opt);
|
|
|
|
|
2017-10-31 18:19:11 +00:00
|
|
|
rev.diffopt.flags.override_submodule_config = 1;
|
2016-10-24 10:42:19 +00:00
|
|
|
rev.diffopt.ita_invisible_in_index = 1;
|
2010-08-05 22:39:25 +00:00
|
|
|
if (s->ignore_submodule_arg) {
|
2010-06-25 14:56:47 +00:00
|
|
|
handle_ignore_submodules_arg(&rev.diffopt, s->ignore_submodule_arg);
|
2014-04-05 16:59:03 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Unless the user did explicitly request a submodule ignore
|
|
|
|
* mode by passing a command line option we do not ignore any
|
|
|
|
* changed submodule SHA-1s when comparing index and HEAD, no
|
|
|
|
* matter what is configured. Otherwise the user won't be
|
2021-06-15 14:11:10 +00:00
|
|
|
* shown any submodules manually added (and which are
|
2014-04-05 16:59:03 +00:00
|
|
|
* staged to be committed), which would be really confusing.
|
|
|
|
*/
|
|
|
|
handle_ignore_submodules_arg(&rev.diffopt, "dirty");
|
2010-08-05 22:39:25 +00:00
|
|
|
}
|
2010-06-25 14:56:47 +00:00
|
|
|
|
2006-09-08 08:05:34 +00:00
|
|
|
rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
|
2009-08-05 06:49:33 +00:00
|
|
|
rev.diffopt.format_callback = wt_status_collect_updated_cb;
|
2006-09-08 08:05:34 +00:00
|
|
|
rev.diffopt.format_callback_data = s;
|
2018-05-11 15:38:58 +00:00
|
|
|
rev.diffopt.detect_rename = s->detect_rename >= 0 ? s->detect_rename : rev.diffopt.detect_rename;
|
|
|
|
rev.diffopt.rename_limit = s->rename_limit >= 0 ? s->rename_limit : rev.diffopt.rename_limit;
|
|
|
|
rev.diffopt.rename_score = s->rename_score >= 0 ? s->rename_score : rev.diffopt.rename_score;
|
2022-03-01 20:24:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The `recursive` option must be enabled to allow the diff to recurse
|
|
|
|
* into subdirectories of sparse directory index entries. If it is not
|
|
|
|
* enabled, a subdirectory containing file(s) with changes is reported
|
|
|
|
* as "modified", rather than the modified files themselves.
|
|
|
|
*/
|
|
|
|
rev.diffopt.flags.recursive = 1;
|
|
|
|
|
2013-07-14 08:35:39 +00:00
|
|
|
copy_pathspec(&rev.prune_data, &s->pathspec);
|
2006-09-08 08:05:34 +00:00
|
|
|
run_diff_index(&rev, 1);
|
revision.[ch]: provide and start using a release_revisions()
The users of the revision.[ch] API's "struct rev_info" are a major
source of memory leaks in the test suite under SANITIZE=leak, which in
turn adds a lot of noise when trying to mark up tests with
"TEST_PASSES_SANITIZE_LEAK=true".
The users of that API are largely one-shot, e.g. "git rev-list" or
"git log", or the "git checkout" and "git stash" being modified here
For these callers freeing the memory is arguably a waste of time, but
in many cases they've actually been trying to free the memory, and
just doing that in a buggy manner.
Let's provide a release_revisions() function for these users, and
start migrating them over per the plan outlined in [1]. Right now this
only handles the "pending" member of the struct, but more will be
added in subsequent commits.
Even though we only clear the "pending" member now, let's not leave a
trap in code like the pre-image of index_differs_from(), where we'd
start doing the wrong thing as soon as the release_revisions() learned
to clear its "diffopt". I.e. we need to call release_revisions() after
we've inspected any state in "struct rev_info".
This leaves in place e.g. clear_pathspec(&rev.prune_data) in
stash_working_tree() in builtin/stash.c, subsequent commits will teach
release_revisions() to free "prune_data" and other members that in
some cases are individually cleared by users of "struct rev_info" by
reaching into its members. Those subsequent commits will remove the
relevant calls to e.g. clear_pathspec().
We avoid amending code in index_differs_from() in diff-lib.c as well
as wt_status_collect_changes_index(), has_unstaged_changes() and
has_uncommitted_changes() in wt-status.c in a way that assumes that we
are already clearing the "diffopt" member. That will be handled in a
subsequent commit.
1. https://lore.kernel.org/git/87a6k8daeu.fsf@evledraar.gmail.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-04-13 20:01:35 +00:00
|
|
|
release_revisions(&rev);
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2021-07-14 13:12:38 +00:00
|
|
|
static int add_file_to_list(const struct object_id *oid,
|
|
|
|
struct strbuf *base, const char *path,
|
|
|
|
unsigned int mode, void *context)
|
|
|
|
{
|
|
|
|
struct string_list_item *it;
|
|
|
|
struct wt_status_change_data *d;
|
|
|
|
struct wt_status *s = context;
|
|
|
|
struct strbuf full_name = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (S_ISDIR(mode))
|
|
|
|
return READ_TREE_RECURSIVE;
|
|
|
|
|
|
|
|
strbuf_add(&full_name, base->buf, base->len);
|
|
|
|
strbuf_addstr(&full_name, path);
|
|
|
|
it = string_list_insert(&s->change, full_name.buf);
|
|
|
|
d = it->util;
|
|
|
|
if (!d) {
|
|
|
|
CALLOC_ARRAY(d, 1);
|
|
|
|
it->util = d;
|
|
|
|
}
|
|
|
|
|
|
|
|
d->index_status = DIFF_STATUS_ADDED;
|
|
|
|
/* Leave {mode,oid}_head zero for adds. */
|
|
|
|
d->mode_index = mode;
|
|
|
|
oidcpy(&d->oid_index, oid);
|
|
|
|
s->committable = 1;
|
|
|
|
strbuf_release(&full_name);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
static void wt_status_collect_changes_initial(struct wt_status *s)
|
|
|
|
{
|
2018-11-10 05:48:49 +00:00
|
|
|
struct index_state *istate = s->repo->index;
|
2009-08-05 06:49:33 +00:00
|
|
|
int i;
|
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
2009-08-05 06:49:33 +00:00
|
|
|
struct string_list_item *it;
|
|
|
|
struct wt_status_change_data *d;
|
2018-11-10 05:48:49 +00:00
|
|
|
const struct cache_entry *ce = istate->cache[i];
|
2009-08-05 06:49:33 +00:00
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
if (!ce_path_match(istate, ce, &s->pathspec, NULL))
|
2009-08-08 06:31:57 +00:00
|
|
|
continue;
|
2016-10-24 10:42:19 +00:00
|
|
|
if (ce_intent_to_add(ce))
|
|
|
|
continue;
|
2021-07-14 13:12:38 +00:00
|
|
|
if (S_ISSPARSEDIR(ce->ce_mode)) {
|
|
|
|
/*
|
|
|
|
* This is a sparse directory entry, so we want to collect all
|
|
|
|
* of the added files within the tree. This requires recursively
|
|
|
|
* expanding the trees to find the elements that are new in this
|
|
|
|
* tree and marking them with DIFF_STATUS_ADDED.
|
|
|
|
*/
|
|
|
|
struct strbuf base = STRBUF_INIT;
|
|
|
|
struct pathspec ps = { 0 };
|
|
|
|
struct tree *tree = lookup_tree(istate->repo, &ce->oid);
|
|
|
|
|
|
|
|
ps.recursive = 1;
|
|
|
|
ps.has_wildcard = 1;
|
|
|
|
ps.max_depth = -1;
|
|
|
|
|
|
|
|
strbuf_add(&base, ce->name, ce->ce_namelen);
|
|
|
|
read_tree_at(istate->repo, tree, &base, &ps,
|
|
|
|
add_file_to_list, s);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-06-25 23:41:35 +00:00
|
|
|
it = string_list_insert(&s->change, ce->name);
|
2009-08-05 06:49:33 +00:00
|
|
|
d = it->util;
|
|
|
|
if (!d) {
|
2021-03-13 16:17:22 +00:00
|
|
|
CALLOC_ARRAY(d, 1);
|
2009-08-05 06:49:33 +00:00
|
|
|
it->util = d;
|
|
|
|
}
|
2009-08-05 07:04:51 +00:00
|
|
|
if (ce_stage(ce)) {
|
2009-08-05 06:49:33 +00:00
|
|
|
d->index_status = DIFF_STATUS_UNMERGED;
|
2009-08-05 07:04:51 +00:00
|
|
|
d->stagemask |= (1 << (ce_stage(ce) - 1));
|
2016-08-11 14:45:57 +00:00
|
|
|
/*
|
|
|
|
* Don't bother setting {mode,oid}_{head,index} since the print
|
|
|
|
* code will output the stage values directly and not use the
|
|
|
|
* values in these fields.
|
|
|
|
*/
|
2018-09-06 00:53:29 +00:00
|
|
|
s->committable = 1;
|
2016-08-11 14:45:57 +00:00
|
|
|
} else {
|
2009-08-05 06:49:33 +00:00
|
|
|
d->index_status = DIFF_STATUS_ADDED;
|
2016-08-11 14:45:57 +00:00
|
|
|
/* Leave {mode,oid}_head zero for adds. */
|
|
|
|
d->mode_index = ce->ce_mode;
|
2017-01-28 22:03:06 +00:00
|
|
|
oidcpy(&d->oid_index, &ce->oid);
|
2018-09-06 00:53:29 +00:00
|
|
|
s->committable = 1;
|
2016-08-11 14:45:57 +00:00
|
|
|
}
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-10 07:36:33 +00:00
|
|
|
static void wt_status_collect_untracked(struct wt_status *s)
|
|
|
|
{
|
|
|
|
int i;
|
2021-07-01 10:51:27 +00:00
|
|
|
struct dir_struct dir = DIR_INIT;
|
2014-07-12 00:07:36 +00:00
|
|
|
uint64_t t_begin = getnanotime();
|
2018-11-10 05:48:49 +00:00
|
|
|
struct index_state *istate = s->repo->index;
|
2009-08-10 07:36:33 +00:00
|
|
|
|
|
|
|
if (!s->show_untracked_files)
|
|
|
|
return;
|
2013-03-13 12:59:16 +00:00
|
|
|
|
2009-08-10 07:36:33 +00:00
|
|
|
if (s->show_untracked_files != SHOW_ALL_UNTRACKED_FILES)
|
|
|
|
dir.flags |=
|
|
|
|
DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;
|
status: add option to show ignored files differently
Teach the status command more flexibility in how ignored files are
reported. Currently, the reporting of ignored files and untracked
files are linked. You cannot control how ignored files are reported
independently of how untracked files are reported (i.e. `all` vs
`normal`). This makes it impossible to show untracked files with the
`all` option, but show ignored files with the `normal` option.
This work 1) adds the ability to control the reporting of ignored
files independently of untracked files and 2) introduces the concept
of status reporting ignored paths that explicitly match an ignored
pattern. There are 2 benefits to these changes: 1) if a consumer needs
all untracked files but not all ignored files, there is a performance
benefit to not scanning all contents of an ignored directory and 2)
returning ignored files that explicitly match a path allow a consumer
to make more informed decisions about when a status result might be
stale.
This commit implements --ignored=matching with --untracked-files=all.
The following commit will implement --ignored=matching with
--untracked=files=normal.
As an example of where this flexibility could be useful is that our
application (Visual Studio) runs the status command and presents the
output. It shows all untracked files individually (e.g. using the
'--untracked-files==all' option), and would like to know about which
paths are ignored. It uses information about ignored paths to make
decisions about when the status result might have changed.
Additionally, many projects place build output into directories inside
a repository's working directory (e.g. in "bin/" and "obj/"
directories). Normal usage is to explicitly ignore these 2 directory
names in the .gitignore file (rather than or in addition to the *.obj
pattern).If an application could know that these directories are
explicitly ignored, it could infer that all contents are ignored as
well and make better informed decisions about files in these
directories. It could infer that any changes under these paths would
not affect the output of status. Additionally, there can be a
significant performance benefit by avoiding scanning through ignored
directories.
When status is set to report matching ignored files, it has the
following behavior. Ignored files and directories that explicitly
match an exclude pattern are reported. If an ignored directory matches
an exclude pattern, then the path of the directory is returned. If a
directory does not match an exclude pattern, but all of its contents
are ignored, then the contained files are reported instead of the
directory.
Signed-off-by: Jameson Miller <jamill@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-30 17:21:37 +00:00
|
|
|
if (s->show_ignored_mode) {
|
2013-04-15 19:15:03 +00:00
|
|
|
dir.flags |= DIR_SHOW_IGNORED_TOO;
|
status: add option to show ignored files differently
Teach the status command more flexibility in how ignored files are
reported. Currently, the reporting of ignored files and untracked
files are linked. You cannot control how ignored files are reported
independently of how untracked files are reported (i.e. `all` vs
`normal`). This makes it impossible to show untracked files with the
`all` option, but show ignored files with the `normal` option.
This work 1) adds the ability to control the reporting of ignored
files independently of untracked files and 2) introduces the concept
of status reporting ignored paths that explicitly match an ignored
pattern. There are 2 benefits to these changes: 1) if a consumer needs
all untracked files but not all ignored files, there is a performance
benefit to not scanning all contents of an ignored directory and 2)
returning ignored files that explicitly match a path allow a consumer
to make more informed decisions about when a status result might be
stale.
This commit implements --ignored=matching with --untracked-files=all.
The following commit will implement --ignored=matching with
--untracked=files=normal.
As an example of where this flexibility could be useful is that our
application (Visual Studio) runs the status command and presents the
output. It shows all untracked files individually (e.g. using the
'--untracked-files==all' option), and would like to know about which
paths are ignored. It uses information about ignored paths to make
decisions about when the status result might have changed.
Additionally, many projects place build output into directories inside
a repository's working directory (e.g. in "bin/" and "obj/"
directories). Normal usage is to explicitly ignore these 2 directory
names in the .gitignore file (rather than or in addition to the *.obj
pattern).If an application could know that these directories are
explicitly ignored, it could infer that all contents are ignored as
well and make better informed decisions about files in these
directories. It could infer that any changes under these paths would
not affect the output of status. Additionally, there can be a
significant performance benefit by avoiding scanning through ignored
directories.
When status is set to report matching ignored files, it has the
following behavior. Ignored files and directories that explicitly
match an exclude pattern are reported. If an ignored directory matches
an exclude pattern, then the path of the directory is returned. If a
directory does not match an exclude pattern, but all of its contents
are ignored, then the contained files are reported instead of the
directory.
Signed-off-by: Jameson Miller <jamill@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-30 17:21:37 +00:00
|
|
|
|
|
|
|
if (s->show_ignored_mode == SHOW_MATCHING_IGNORED)
|
|
|
|
dir.flags |= DIR_SHOW_IGNORED_TOO_MODE_MATCHING;
|
|
|
|
} else {
|
2018-11-10 05:48:49 +00:00
|
|
|
dir.untracked = istate->untracked;
|
status: add option to show ignored files differently
Teach the status command more flexibility in how ignored files are
reported. Currently, the reporting of ignored files and untracked
files are linked. You cannot control how ignored files are reported
independently of how untracked files are reported (i.e. `all` vs
`normal`). This makes it impossible to show untracked files with the
`all` option, but show ignored files with the `normal` option.
This work 1) adds the ability to control the reporting of ignored
files independently of untracked files and 2) introduces the concept
of status reporting ignored paths that explicitly match an ignored
pattern. There are 2 benefits to these changes: 1) if a consumer needs
all untracked files but not all ignored files, there is a performance
benefit to not scanning all contents of an ignored directory and 2)
returning ignored files that explicitly match a path allow a consumer
to make more informed decisions about when a status result might be
stale.
This commit implements --ignored=matching with --untracked-files=all.
The following commit will implement --ignored=matching with
--untracked=files=normal.
As an example of where this flexibility could be useful is that our
application (Visual Studio) runs the status command and presents the
output. It shows all untracked files individually (e.g. using the
'--untracked-files==all' option), and would like to know about which
paths are ignored. It uses information about ignored paths to make
decisions about when the status result might have changed.
Additionally, many projects place build output into directories inside
a repository's working directory (e.g. in "bin/" and "obj/"
directories). Normal usage is to explicitly ignore these 2 directory
names in the .gitignore file (rather than or in addition to the *.obj
pattern).If an application could know that these directories are
explicitly ignored, it could infer that all contents are ignored as
well and make better informed decisions about files in these
directories. It could infer that any changes under these paths would
not affect the output of status. Additionally, there can be a
significant performance benefit by avoiding scanning through ignored
directories.
When status is set to report matching ignored files, it has the
following behavior. Ignored files and directories that explicitly
match an exclude pattern are reported. If an ignored directory matches
an exclude pattern, then the path of the directory is returned. If a
directory does not match an exclude pattern, but all of its contents
are ignored, then the contained files are reported instead of the
directory.
Signed-off-by: Jameson Miller <jamill@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-30 17:21:37 +00:00
|
|
|
}
|
|
|
|
|
2009-08-10 07:36:33 +00:00
|
|
|
setup_standard_excludes(&dir);
|
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
fill_directory(&dir, istate, &s->pathspec);
|
2013-04-15 19:15:03 +00:00
|
|
|
|
2009-09-01 05:35:10 +00:00
|
|
|
for (i = 0; i < dir.nr; i++) {
|
2009-08-10 07:36:33 +00:00
|
|
|
struct dir_entry *ent = dir.entries[i];
|
Fix error-prone fill_directory() API; make it only return matches
Traditionally, the expected calling convention for the dir.c API was:
fill_directory(&dir, ..., pathspec)
foreach entry in dir->entries:
if (dir_path_match(entry, pathspec))
process_or_display(entry)
This may have made sense once upon a time, because the fill_directory() call
could use cheap checks to avoid doing full pathspec matching, and an external
caller may have wanted to do other post-processing of the results anyway.
However:
* this structure makes it easy for users of the API to get it wrong
* this structure actually makes it harder to understand
fill_directory() and the functions it uses internally. It has
tripped me up several times while trying to fix bugs and
restructure things.
* relying on post-filtering was already found to produce wrong
results; pathspec matching had to be added internally for multiple
cases in order to get the right results (see commits 404ebceda01c
(dir: also check directories for matching pathspecs, 2019-09-17)
and 89a1f4aaf765 (dir: if our pathspec might match files under a
dir, recurse into it, 2019-09-17))
* it's bad for performance: fill_directory() already has to do lots
of checks and knows the subset of cases where it still needs to do
more checks. Forcing external callers to do full pathspec
matching means they must re-check _every_ path.
So, add the pathspec matching within the fill_directory() internals, and
remove it from external callers.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-01 04:17:45 +00:00
|
|
|
if (index_name_is_other(istate, ent->name, ent->len))
|
2010-09-27 02:49:13 +00:00
|
|
|
string_list_insert(&s->untracked, ent->name);
|
2009-08-10 07:36:33 +00:00
|
|
|
}
|
2010-04-10 06:58:27 +00:00
|
|
|
|
2013-04-15 19:15:03 +00:00
|
|
|
for (i = 0; i < dir.ignored_nr; i++) {
|
|
|
|
struct dir_entry *ent = dir.ignored[i];
|
Fix error-prone fill_directory() API; make it only return matches
Traditionally, the expected calling convention for the dir.c API was:
fill_directory(&dir, ..., pathspec)
foreach entry in dir->entries:
if (dir_path_match(entry, pathspec))
process_or_display(entry)
This may have made sense once upon a time, because the fill_directory() call
could use cheap checks to avoid doing full pathspec matching, and an external
caller may have wanted to do other post-processing of the results anyway.
However:
* this structure makes it easy for users of the API to get it wrong
* this structure actually makes it harder to understand
fill_directory() and the functions it uses internally. It has
tripped me up several times while trying to fix bugs and
restructure things.
* relying on post-filtering was already found to produce wrong
results; pathspec matching had to be added internally for multiple
cases in order to get the right results (see commits 404ebceda01c
(dir: also check directories for matching pathspecs, 2019-09-17)
and 89a1f4aaf765 (dir: if our pathspec might match files under a
dir, recurse into it, 2019-09-17))
* it's bad for performance: fill_directory() already has to do lots
of checks and knows the subset of cases where it still needs to do
more checks. Forcing external callers to do full pathspec
matching means they must re-check _every_ path.
So, add the pathspec matching within the fill_directory() internals, and
remove it from external callers.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-04-01 04:17:45 +00:00
|
|
|
if (index_name_is_other(istate, ent->name, ent->len))
|
2013-04-15 19:15:03 +00:00
|
|
|
string_list_insert(&s->ignored, ent->name);
|
2010-04-10 07:11:53 +00:00
|
|
|
}
|
|
|
|
|
dir: fix problematic API to avoid memory leaks
The dir structure seemed to have a number of leaks and problems around
it. First I noticed that parent_hashmap and recursive_hashmap were
being leaked (though Peff noticed and submitted fixes before me). Then
I noticed in the previous commit that clear_directory() was only taking
responsibility for a subset of fields within dir_struct, despite the
fact that entries[] and ignored[] we allocated internally to dir.c.
That, of course, resulted in many callers either leaking or haphazardly
trying to free these arrays and their contents.
Digging further, I found that despite the pretty clear documentation
near the top of dir.h that folks were supposed to call clear_directory()
when the user no longer needed the dir_struct, there were four callers
that didn't bother doing that at all. However, two of them clearly
thought about leaks since they had an UNLEAK(dir) directive, which to me
suggests that the method to free the data was too unclear. I suspect
the non-obviousness of the API and its holes led folks to avoid it,
which then snowballed into further problems with the entries[],
ignored[], parent_hashmap, and recursive_hashmap problems.
Rename clear_directory() to dir_clear() to be more in line with other
data structures in git, and introduce a dir_init() to handle the
suggested memsetting of dir_struct to all zeroes. I hope that a name
like "dir_clear()" is more clear, and that the presence of dir_init()
will provide a hint to those looking at the code that they need to look
for either a dir_clear() or a dir_free() and lead them to find
dir_clear().
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-08-18 22:58:26 +00:00
|
|
|
dir_clear(&dir);
|
2013-03-13 12:59:16 +00:00
|
|
|
|
2021-08-23 10:44:00 +00:00
|
|
|
if (advice_enabled(ADVICE_STATUS_U_OPTION))
|
2014-07-12 00:07:36 +00:00
|
|
|
s->untracked_in_ms = (getnanotime() - t_begin) / 1000000;
|
2009-08-10 07:36:33 +00:00
|
|
|
}
|
|
|
|
|
2018-09-06 00:53:26 +00:00
|
|
|
static int has_unmerged(struct wt_status *s)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < s->change.nr; i++) {
|
|
|
|
struct wt_status_change_data *d;
|
|
|
|
d = s->change.items[i].util;
|
|
|
|
if (d->stagemask)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-10 07:36:33 +00:00
|
|
|
void wt_status_collect(struct wt_status *s)
|
2009-08-05 06:49:33 +00:00
|
|
|
{
|
2019-02-22 22:25:03 +00:00
|
|
|
trace2_region_enter("status", "worktrees", s->repo);
|
2009-08-05 06:49:33 +00:00
|
|
|
wt_status_collect_changes_worktree(s);
|
2019-02-22 22:25:03 +00:00
|
|
|
trace2_region_leave("status", "worktrees", s->repo);
|
|
|
|
|
|
|
|
if (s->is_initial) {
|
|
|
|
trace2_region_enter("status", "initial", s->repo);
|
2009-08-05 06:49:33 +00:00
|
|
|
wt_status_collect_changes_initial(s);
|
2019-02-22 22:25:03 +00:00
|
|
|
trace2_region_leave("status", "initial", s->repo);
|
|
|
|
} else {
|
|
|
|
trace2_region_enter("status", "index", s->repo);
|
2009-08-05 06:49:33 +00:00
|
|
|
wt_status_collect_changes_index(s);
|
2019-02-22 22:25:03 +00:00
|
|
|
trace2_region_leave("status", "index", s->repo);
|
|
|
|
}
|
|
|
|
|
|
|
|
trace2_region_enter("status", "untracked", s->repo);
|
2009-08-10 07:36:33 +00:00
|
|
|
wt_status_collect_untracked(s);
|
2019-02-22 22:25:03 +00:00
|
|
|
trace2_region_leave("status", "untracked", s->repo);
|
2018-09-06 00:53:29 +00:00
|
|
|
|
2018-11-10 05:48:50 +00:00
|
|
|
wt_status_get_state(s->repo, &s->state, s->branch && !strcmp(s->branch, "HEAD"));
|
2018-09-30 14:12:45 +00:00
|
|
|
if (s->state.merge_in_progress && !has_unmerged(s))
|
2018-09-06 00:53:29 +00:00
|
|
|
s->committable = 1;
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
|
|
|
|
2018-09-30 14:12:45 +00:00
|
|
|
void wt_status_collect_free_buffers(struct wt_status *s)
|
|
|
|
{
|
wt-status: introduce wt_status_state_free_buffers()
When we have a `struct wt_status_state`, we manually free its `branch`,
`onto` and `detached_from`, or sometimes just one or two of them.
Provide a function `wt_status_state_free_buffers()` which does the
freeing.
The callers are still aware of these fields, e.g., they check whether
`branch` was populated or not. But this way, they don't need to know
about *all* of them, and if `struct wt_status_state` gets more fields,
they will not need to learn to free them.
Users of `struct wt_status` (which contains a `wt_status_state`) already
have `wt_status_collect_free_buffers()` (corresponding to
`wt_status_collect()`) which we can also teach to use this new helper.
Finally, note that we're currently leaving dangling pointers behind.
Some callers work on a stack-allocated struct, where this is obviously
ok. But for the users of `run_status()` in builtin/commit.c, there are
ample opportunities for someone to mistakenly use those dangling
pointers. We seem to be ok for now, but it's a use-after-free waiting to
happen. Let's leave NULL-pointers behind instead.
Signed-off-by: Martin Ågren <martin.agren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-09-27 13:15:43 +00:00
|
|
|
wt_status_state_free_buffers(&s->state);
|
|
|
|
}
|
|
|
|
|
|
|
|
void wt_status_state_free_buffers(struct wt_status_state *state)
|
|
|
|
{
|
|
|
|
FREE_AND_NULL(state->branch);
|
|
|
|
FREE_AND_NULL(state->onto);
|
|
|
|
FREE_AND_NULL(state->detached_from);
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_unmerged(struct wt_status *s)
|
2009-08-05 07:04:51 +00:00
|
|
|
{
|
|
|
|
int shown_header = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < s->change.nr; i++) {
|
|
|
|
struct wt_status_change_data *d;
|
|
|
|
struct string_list_item *it;
|
|
|
|
it = &(s->change.items[i]);
|
|
|
|
d = it->util;
|
|
|
|
if (!d->stagemask)
|
|
|
|
continue;
|
|
|
|
if (!shown_header) {
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_unmerged_header(s);
|
2009-08-05 07:04:51 +00:00
|
|
|
shown_header = 1;
|
|
|
|
}
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_unmerged_data(s, it);
|
2009-08-05 07:04:51 +00:00
|
|
|
}
|
|
|
|
if (shown_header)
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2009-08-05 07:04:51 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_updated(struct wt_status *s)
|
2009-08-05 06:49:33 +00:00
|
|
|
{
|
|
|
|
int shown_header = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < s->change.nr; i++) {
|
|
|
|
struct wt_status_change_data *d;
|
|
|
|
struct string_list_item *it;
|
|
|
|
it = &(s->change.items[i]);
|
|
|
|
d = it->util;
|
|
|
|
if (!d->index_status ||
|
|
|
|
d->index_status == DIFF_STATUS_UNMERGED)
|
|
|
|
continue;
|
|
|
|
if (!shown_header) {
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_cached_header(s);
|
2009-08-05 06:49:33 +00:00
|
|
|
shown_header = 1;
|
|
|
|
}
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_change_data(s, WT_STATUS_UPDATED, it);
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
|
|
|
if (shown_header)
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* -1 : has delete
|
|
|
|
* 0 : no change
|
|
|
|
* 1 : some change but no delete
|
|
|
|
*/
|
2010-03-08 12:53:19 +00:00
|
|
|
static int wt_status_check_worktree_changes(struct wt_status *s,
|
|
|
|
int *dirty_submodules)
|
2009-08-05 06:49:33 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int changes = 0;
|
|
|
|
|
2010-03-08 12:53:19 +00:00
|
|
|
*dirty_submodules = 0;
|
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
for (i = 0; i < s->change.nr; i++) {
|
|
|
|
struct wt_status_change_data *d;
|
|
|
|
d = s->change.items[i].util;
|
2009-08-05 07:04:51 +00:00
|
|
|
if (!d->worktree_status ||
|
|
|
|
d->worktree_status == DIFF_STATUS_UNMERGED)
|
2009-08-05 06:49:33 +00:00
|
|
|
continue;
|
2010-03-08 12:53:19 +00:00
|
|
|
if (!changes)
|
|
|
|
changes = 1;
|
|
|
|
if (d->dirty_submodule)
|
|
|
|
*dirty_submodules = 1;
|
2009-08-05 06:49:33 +00:00
|
|
|
if (d->worktree_status == DIFF_STATUS_DELETED)
|
2010-03-08 12:53:19 +00:00
|
|
|
changes = -1;
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
|
|
|
return changes;
|
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_changed(struct wt_status *s)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
2010-03-08 12:53:19 +00:00
|
|
|
int i, dirty_submodules;
|
|
|
|
int worktree_changes = wt_status_check_worktree_changes(s, &dirty_submodules);
|
2009-08-05 06:49:33 +00:00
|
|
|
|
|
|
|
if (!worktree_changes)
|
|
|
|
return;
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_dirty_header(s, worktree_changes < 0, dirty_submodules);
|
2009-08-05 06:49:33 +00:00
|
|
|
|
|
|
|
for (i = 0; i < s->change.nr; i++) {
|
|
|
|
struct wt_status_change_data *d;
|
|
|
|
struct string_list_item *it;
|
|
|
|
it = &(s->change.items[i]);
|
|
|
|
d = it->util;
|
2009-08-05 07:04:51 +00:00
|
|
|
if (!d->worktree_status ||
|
|
|
|
d->worktree_status == DIFF_STATUS_UNMERGED)
|
2009-08-05 06:49:33 +00:00
|
|
|
continue;
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_change_data(s, WT_STATUS_CHANGED, it);
|
2009-08-05 06:49:33 +00:00
|
|
|
}
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2017-06-17 22:30:51 +00:00
|
|
|
static int stash_count_refs(struct object_id *ooid, struct object_id *noid,
|
|
|
|
const char *email, timestamp_t timestamp, int tz,
|
|
|
|
const char *message, void *cb_data)
|
|
|
|
{
|
|
|
|
int *c = cb_data;
|
|
|
|
(*c)++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-10-21 22:25:31 +00:00
|
|
|
static int count_stash_entries(void)
|
|
|
|
{
|
|
|
|
int n = 0;
|
|
|
|
for_each_reflog_ent("refs/stash", stash_count_refs, &n);
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2017-06-17 22:30:51 +00:00
|
|
|
static void wt_longstatus_print_stash_summary(struct wt_status *s)
|
|
|
|
{
|
2021-10-21 22:25:31 +00:00
|
|
|
int stash_count = count_stash_entries();
|
2017-06-17 22:30:51 +00:00
|
|
|
|
|
|
|
if (stash_count > 0)
|
|
|
|
status_printf_ln(s, GIT_COLOR_NORMAL,
|
|
|
|
Q_("Your stash currently has %d entry",
|
|
|
|
"Your stash currently has %d entries", stash_count),
|
|
|
|
stash_count);
|
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_submodule_summary(struct wt_status *s, int uncommitted)
|
2008-04-12 15:05:32 +00:00
|
|
|
{
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process sm_summary = CHILD_PROCESS_INIT;
|
2013-09-06 17:43:06 +00:00
|
|
|
struct strbuf cmd_stdout = STRBUF_INIT;
|
|
|
|
struct strbuf summary = STRBUF_INIT;
|
|
|
|
char *summary_content;
|
2008-04-12 15:05:32 +00:00
|
|
|
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
strvec_pushf(&sm_summary.env_array, "GIT_INDEX_FILE=%s", s->index_file);
|
2008-04-12 15:05:32 +00:00
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&sm_summary.args, "submodule");
|
|
|
|
strvec_push(&sm_summary.args, "summary");
|
|
|
|
strvec_push(&sm_summary.args, uncommitted ? "--files" : "--cached");
|
|
|
|
strvec_push(&sm_summary.args, "--for-status");
|
|
|
|
strvec_push(&sm_summary.args, "--summary-limit");
|
|
|
|
strvec_pushf(&sm_summary.args, "%d", s->submodule_summary);
|
2013-09-06 17:43:05 +00:00
|
|
|
if (!uncommitted)
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&sm_summary.args, s->amend ? "HEAD^" : "HEAD");
|
2013-09-06 17:43:05 +00:00
|
|
|
|
2008-04-12 15:05:32 +00:00
|
|
|
sm_summary.git_cmd = 1;
|
|
|
|
sm_summary.no_stdin = 1;
|
2013-09-06 17:43:06 +00:00
|
|
|
|
2015-03-23 03:53:52 +00:00
|
|
|
capture_command(&sm_summary, &cmd_stdout, 1024);
|
2013-09-06 17:43:06 +00:00
|
|
|
|
|
|
|
/* prepend header, only if there's an actual output */
|
2015-03-22 10:00:32 +00:00
|
|
|
if (cmd_stdout.len) {
|
2013-09-06 17:43:06 +00:00
|
|
|
if (uncommitted)
|
|
|
|
strbuf_addstr(&summary, _("Submodules changed but not updated:"));
|
|
|
|
else
|
|
|
|
strbuf_addstr(&summary, _("Submodule changes to be committed:"));
|
|
|
|
strbuf_addstr(&summary, "\n\n");
|
|
|
|
}
|
|
|
|
strbuf_addbuf(&summary, &cmd_stdout);
|
|
|
|
strbuf_release(&cmd_stdout);
|
|
|
|
|
2013-09-06 17:43:07 +00:00
|
|
|
if (s->display_comment_prefix) {
|
2015-03-22 10:00:32 +00:00
|
|
|
size_t len;
|
2013-09-06 17:43:07 +00:00
|
|
|
summary_content = strbuf_detach(&summary, &len);
|
|
|
|
strbuf_add_commented_lines(&summary, summary_content, len);
|
|
|
|
free(summary_content);
|
|
|
|
}
|
2013-09-06 17:43:06 +00:00
|
|
|
|
|
|
|
fputs(summary.buf, s->fp);
|
|
|
|
strbuf_release(&summary);
|
2008-04-12 15:05:32 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_other(struct wt_status *s,
|
|
|
|
struct string_list *l,
|
|
|
|
const char *what,
|
|
|
|
const char *how)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
|
|
|
int i;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2012-04-13 10:54:39 +00:00
|
|
|
static struct string_list output = STRING_LIST_INIT_DUP;
|
|
|
|
struct column_options copts;
|
2006-09-08 08:05:34 +00:00
|
|
|
|
2011-06-02 05:54:49 +00:00
|
|
|
if (!l->nr)
|
2009-08-10 07:36:33 +00:00
|
|
|
return;
|
2006-09-08 08:05:34 +00:00
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_other_header(s, what, how);
|
2010-04-10 07:19:46 +00:00
|
|
|
|
|
|
|
for (i = 0; i < l->nr; i++) {
|
2009-08-10 07:36:33 +00:00
|
|
|
struct string_list_item *it;
|
2012-04-13 10:54:39 +00:00
|
|
|
const char *path;
|
2010-04-10 07:19:46 +00:00
|
|
|
it = &(l->items[i]);
|
2020-09-10 17:01:54 +00:00
|
|
|
path = quote_path(it->string, s->prefix, &buf, 0);
|
2012-04-13 10:54:39 +00:00
|
|
|
if (column_active(s->colopts)) {
|
|
|
|
string_list_append(&output, path);
|
|
|
|
continue;
|
|
|
|
}
|
2011-02-26 05:11:37 +00:00
|
|
|
status_printf(s, color(WT_STATUS_HEADER, s), "\t");
|
|
|
|
status_printf_more(s, color(WT_STATUS_UNTRACKED, s),
|
2012-04-13 10:54:39 +00:00
|
|
|
"%s\n", path);
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
2012-04-13 10:54:39 +00:00
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
if (!column_active(s->colopts))
|
2013-09-06 17:43:09 +00:00
|
|
|
goto conclude;
|
2012-04-13 10:54:39 +00:00
|
|
|
|
2013-09-06 17:43:07 +00:00
|
|
|
strbuf_addf(&buf, "%s%s\t%s",
|
2012-04-13 10:54:39 +00:00
|
|
|
color(WT_STATUS_HEADER, s),
|
2013-09-06 17:43:07 +00:00
|
|
|
s->display_comment_prefix ? "#" : "",
|
2012-04-13 10:54:39 +00:00
|
|
|
color(WT_STATUS_UNTRACKED, s));
|
|
|
|
memset(&copts, 0, sizeof(copts));
|
|
|
|
copts.padding = 1;
|
|
|
|
copts.indent = buf.buf;
|
|
|
|
if (want_color(s->use_color))
|
|
|
|
copts.nl = GIT_COLOR_RESET "\n";
|
|
|
|
print_columns(&output, s->colopts, &copts);
|
|
|
|
string_list_clear(&output, 0);
|
2007-11-11 17:35:41 +00:00
|
|
|
strbuf_release(&buf);
|
2013-09-06 17:43:09 +00:00
|
|
|
conclude:
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf_ln(s, GIT_COLOR_NORMAL, "%s", "");
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
interpret-trailers: honor the cut line
If a commit message is edited with the "verbose" option, the buffer
will have a cut line and diff after the log message, like so:
my subject
# ------------------------ >8 ------------------------
# Do not touch the line above.
# Everything below will be removed.
diff --git a/foo.txt b/foo.txt
index 5716ca5..7601807 100644
--- a/foo.txt
+++ b/foo.txt
@@ -1 +1 @@
-bar
+baz
"git interpret-trailers" is unaware of the cut line, and assumes the
trailer block would be at the end of the whole thing. This can easily
be seen with:
$ GIT_EDITOR='git interpret-trailers --in-place --trailer Acked-by:me' \
git commit --amend -v
Teach "git interpret-trailers" to notice the cut-line and ignore the
remainder of the input when looking for a place to add new trailer
block. This makes it consistent with how "git commit -v -s" inserts a
new Signed-off-by: line.
This can be done by the same logic as the existing helper function,
wt_status_truncate_message_at_cut_line(), uses, but it wants the caller
to pass a strbuf to it. Because the function ignore_non_trailer() used
by the command takes a <pointer, length> pair, not a strbuf, steal the
logic from wt_status_truncate_message_at_cut_line() to create a new
wt_status_locate_end() helper function that takes <pointer, length>
pair, and make ignore_non_trailer() call it to help "interpret-trailers".
Since there is only one caller of wt_status_truncate_message_at_cut_line()
in cmd_commit(), rewrite it to call wt_status_locate_end() helper instead
and remove the old helper that no longer has any caller.
Signed-off-by: Brian Malehorn <bmalehorn@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-16 06:06:49 +00:00
|
|
|
size_t wt_status_locate_end(const char *s, size_t len)
|
2013-12-05 19:44:14 +00:00
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
struct strbuf pattern = STRBUF_INIT;
|
|
|
|
|
commit: cope with scissors lines in commit message
The diff and submodule shortlog appended to the commit message template
by 'git commit --verbose' are not stripped when the commit message
contains an indented scissors line.
When cleaning up a commit message with 'git commit --verbose' or
'--cleanup=scissors' the code is careful and triggers only on a pure
scissors line, i.e. a line containing nothing but a comment character, a
space, and the scissors cut. This is good, because people can embed
scissors lines in the commit message while using 'git commit --verbose',
and the text they write after their indented scissors line doesn't get
deleted.
While doing so, however, the cleanup function only looks at the first
line matching the scissors pattern and if it doesn't start at the
beginning of the line, then the function just returns without performing
any cleanup. This is wrong, because a "real" scissors line added by
'git commit --verbose' might follow, and in that case the diff and
submodule shortlog get included in the commit message.
Fix this by changing the scissors pattern to match only at the beginning
of the line, yet be careful to catch scissors on the first line as well.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-06-09 00:28:34 +00:00
|
|
|
strbuf_addf(&pattern, "\n%c %s", comment_line_char, cut_line);
|
interpret-trailers: honor the cut line
If a commit message is edited with the "verbose" option, the buffer
will have a cut line and diff after the log message, like so:
my subject
# ------------------------ >8 ------------------------
# Do not touch the line above.
# Everything below will be removed.
diff --git a/foo.txt b/foo.txt
index 5716ca5..7601807 100644
--- a/foo.txt
+++ b/foo.txt
@@ -1 +1 @@
-bar
+baz
"git interpret-trailers" is unaware of the cut line, and assumes the
trailer block would be at the end of the whole thing. This can easily
be seen with:
$ GIT_EDITOR='git interpret-trailers --in-place --trailer Acked-by:me' \
git commit --amend -v
Teach "git interpret-trailers" to notice the cut-line and ignore the
remainder of the input when looking for a place to add new trailer
block. This makes it consistent with how "git commit -v -s" inserts a
new Signed-off-by: line.
This can be done by the same logic as the existing helper function,
wt_status_truncate_message_at_cut_line(), uses, but it wants the caller
to pass a strbuf to it. Because the function ignore_non_trailer() used
by the command takes a <pointer, length> pair, not a strbuf, steal the
logic from wt_status_truncate_message_at_cut_line() to create a new
wt_status_locate_end() helper function that takes <pointer, length>
pair, and make ignore_non_trailer() call it to help "interpret-trailers".
Since there is only one caller of wt_status_truncate_message_at_cut_line()
in cmd_commit(), rewrite it to call wt_status_locate_end() helper instead
and remove the old helper that no longer has any caller.
Signed-off-by: Brian Malehorn <bmalehorn@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-16 06:06:49 +00:00
|
|
|
if (starts_with(s, pattern.buf + 1))
|
|
|
|
len = 0;
|
|
|
|
else if ((p = strstr(s, pattern.buf)))
|
|
|
|
len = p - s + 1;
|
2013-12-05 19:44:14 +00:00
|
|
|
strbuf_release(&pattern);
|
interpret-trailers: honor the cut line
If a commit message is edited with the "verbose" option, the buffer
will have a cut line and diff after the log message, like so:
my subject
# ------------------------ >8 ------------------------
# Do not touch the line above.
# Everything below will be removed.
diff --git a/foo.txt b/foo.txt
index 5716ca5..7601807 100644
--- a/foo.txt
+++ b/foo.txt
@@ -1 +1 @@
-bar
+baz
"git interpret-trailers" is unaware of the cut line, and assumes the
trailer block would be at the end of the whole thing. This can easily
be seen with:
$ GIT_EDITOR='git interpret-trailers --in-place --trailer Acked-by:me' \
git commit --amend -v
Teach "git interpret-trailers" to notice the cut-line and ignore the
remainder of the input when looking for a place to add new trailer
block. This makes it consistent with how "git commit -v -s" inserts a
new Signed-off-by: line.
This can be done by the same logic as the existing helper function,
wt_status_truncate_message_at_cut_line(), uses, but it wants the caller
to pass a strbuf to it. Because the function ignore_non_trailer() used
by the command takes a <pointer, length> pair, not a strbuf, steal the
logic from wt_status_truncate_message_at_cut_line() to create a new
wt_status_locate_end() helper function that takes <pointer, length>
pair, and make ignore_non_trailer() call it to help "interpret-trailers".
Since there is only one caller of wt_status_truncate_message_at_cut_line()
in cmd_commit(), rewrite it to call wt_status_locate_end() helper instead
and remove the old helper that no longer has any caller.
Signed-off-by: Brian Malehorn <bmalehorn@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-16 06:06:49 +00:00
|
|
|
return len;
|
2013-12-05 19:44:14 +00:00
|
|
|
}
|
|
|
|
|
2019-04-17 10:23:27 +00:00
|
|
|
void wt_status_append_cut_line(struct strbuf *buf)
|
2014-02-17 12:15:31 +00:00
|
|
|
{
|
2017-09-13 13:05:38 +00:00
|
|
|
const char *explanation = _("Do not modify or remove the line above.\nEverything below it will be ignored.");
|
2019-04-17 10:23:27 +00:00
|
|
|
|
|
|
|
strbuf_commented_addf(buf, "%s", cut_line);
|
|
|
|
strbuf_add_commented_lines(buf, explanation, strlen(explanation));
|
|
|
|
}
|
|
|
|
|
|
|
|
void wt_status_add_cut_line(FILE *fp)
|
|
|
|
{
|
2014-02-17 12:15:31 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
2019-04-17 10:23:27 +00:00
|
|
|
wt_status_append_cut_line(&buf);
|
2014-02-17 12:15:31 +00:00
|
|
|
fputs(buf.buf, fp);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_verbose(struct wt_status *s)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
2010-03-09 06:58:09 +00:00
|
|
|
struct setup_revision_opt opt;
|
2015-03-06 09:43:35 +00:00
|
|
|
int dirty_submodules;
|
|
|
|
const char *c = color(WT_STATUS_HEADER, s);
|
2007-11-22 02:54:49 +00:00
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
repo_init_revisions(s->repo, &rev, NULL);
|
2017-10-31 18:19:11 +00:00
|
|
|
rev.diffopt.flags.allow_textconv = 1;
|
2016-10-24 10:42:19 +00:00
|
|
|
rev.diffopt.ita_invisible_in_index = 1;
|
2010-03-09 06:58:09 +00:00
|
|
|
|
|
|
|
memset(&opt, 0, sizeof(opt));
|
2018-05-02 00:26:00 +00:00
|
|
|
opt.def = s->is_initial ? empty_tree_oid_hex() : s->reference;
|
2010-03-09 06:58:09 +00:00
|
|
|
setup_revisions(0, NULL, &rev, &opt);
|
|
|
|
|
2006-09-08 08:05:34 +00:00
|
|
|
rev.diffopt.output_format |= DIFF_FORMAT_PATCH;
|
2018-05-11 15:38:58 +00:00
|
|
|
rev.diffopt.detect_rename = s->detect_rename >= 0 ? s->detect_rename : rev.diffopt.detect_rename;
|
|
|
|
rev.diffopt.rename_limit = s->rename_limit >= 0 ? s->rename_limit : rev.diffopt.rename_limit;
|
|
|
|
rev.diffopt.rename_score = s->rename_score >= 0 ? s->rename_score : rev.diffopt.rename_score;
|
2008-03-10 17:58:26 +00:00
|
|
|
rev.diffopt.file = s->fp;
|
|
|
|
rev.diffopt.close_file = 0;
|
2008-10-26 04:49:35 +00:00
|
|
|
/*
|
|
|
|
* If we're not going to stdout, then we definitely don't
|
|
|
|
* want color, since we are going to the commit message
|
|
|
|
* file (and even the "auto" setting won't work, since it
|
2013-12-05 19:44:14 +00:00
|
|
|
* will have checked isatty on stdout). But we then do want
|
|
|
|
* to insert the scissor line here to reliably remove the
|
|
|
|
* diff before committing.
|
2008-10-26 04:49:35 +00:00
|
|
|
*/
|
2013-12-05 19:44:14 +00:00
|
|
|
if (s->fp != stdout) {
|
2011-08-18 05:03:12 +00:00
|
|
|
rev.diffopt.use_color = 0;
|
2014-02-17 12:15:31 +00:00
|
|
|
wt_status_add_cut_line(s->fp);
|
2013-12-05 19:44:14 +00:00
|
|
|
}
|
2018-09-06 00:53:27 +00:00
|
|
|
if (s->verbose > 1 && s->committable) {
|
2015-03-06 09:43:35 +00:00
|
|
|
/* print_updated() printed a header, so do we */
|
|
|
|
if (s->fp != stdout)
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2015-03-06 09:43:35 +00:00
|
|
|
status_printf_ln(s, c, _("Changes to be committed:"));
|
|
|
|
rev.diffopt.a_prefix = "c/";
|
|
|
|
rev.diffopt.b_prefix = "i/";
|
|
|
|
} /* else use prefix as per user config */
|
2006-09-08 08:05:34 +00:00
|
|
|
run_diff_index(&rev, 1);
|
2015-03-06 09:43:35 +00:00
|
|
|
if (s->verbose > 1 &&
|
|
|
|
wt_status_check_worktree_changes(s, &dirty_submodules)) {
|
|
|
|
status_printf_ln(s, c,
|
|
|
|
"--------------------------------------------------");
|
|
|
|
status_printf_ln(s, c, _("Changes not staged for commit:"));
|
|
|
|
setup_work_tree();
|
|
|
|
rev.diffopt.a_prefix = "i/";
|
|
|
|
rev.diffopt.b_prefix = "w/";
|
|
|
|
run_diff_files(&rev, 0);
|
|
|
|
}
|
2022-04-13 20:01:36 +00:00
|
|
|
release_revisions(&rev);
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_tracking(struct wt_status *s)
|
2008-07-02 07:52:16 +00:00
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2015-10-31 17:37:43 +00:00
|
|
|
const char *cp, *ep, *branch_name;
|
2008-07-02 07:52:16 +00:00
|
|
|
struct branch *branch;
|
2013-09-06 17:43:07 +00:00
|
|
|
char comment_line_string[3];
|
|
|
|
int i;
|
2019-06-18 20:21:27 +00:00
|
|
|
uint64_t t_begin = 0;
|
2008-07-02 07:52:16 +00:00
|
|
|
|
|
|
|
assert(s->branch && !s->is_initial);
|
2015-10-31 17:37:43 +00:00
|
|
|
if (!skip_prefix(s->branch, "refs/heads/", &branch_name))
|
2008-07-02 07:52:16 +00:00
|
|
|
return;
|
2015-10-31 17:37:43 +00:00
|
|
|
branch = branch_get(branch_name);
|
2019-06-18 20:21:27 +00:00
|
|
|
|
|
|
|
t_begin = getnanotime();
|
|
|
|
|
2018-01-09 18:50:18 +00:00
|
|
|
if (!format_tracking_info(branch, &sb, s->ahead_behind_flags))
|
2008-07-02 07:52:16 +00:00
|
|
|
return;
|
|
|
|
|
2021-08-23 10:44:00 +00:00
|
|
|
if (advice_enabled(ADVICE_STATUS_AHEAD_BEHIND_WARNING) &&
|
2019-06-18 20:21:27 +00:00
|
|
|
s->ahead_behind_flags == AHEAD_BEHIND_FULL) {
|
|
|
|
uint64_t t_delta_in_ms = (getnanotime() - t_begin) / 1000000;
|
|
|
|
if (t_delta_in_ms > AB_DELAY_WARNING_IN_MS) {
|
|
|
|
strbuf_addf(&sb, _("\n"
|
|
|
|
"It took %.2f seconds to compute the branch ahead/behind values.\n"
|
|
|
|
"You can use '--no-ahead-behind' to avoid this.\n"),
|
|
|
|
t_delta_in_ms / 1000.0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-06 17:43:07 +00:00
|
|
|
i = 0;
|
|
|
|
if (s->display_comment_prefix) {
|
|
|
|
comment_line_string[i++] = comment_line_char;
|
|
|
|
comment_line_string[i++] = ' ';
|
|
|
|
}
|
|
|
|
comment_line_string[i] = '\0';
|
|
|
|
|
2008-07-02 07:52:16 +00:00
|
|
|
for (cp = sb.buf; (ep = strchr(cp, '\n')) != NULL; cp = ep + 1)
|
2009-08-10 04:59:30 +00:00
|
|
|
color_fprintf_ln(s->fp, color(WT_STATUS_HEADER, s),
|
2013-09-06 17:43:07 +00:00
|
|
|
"%s%.*s", comment_line_string,
|
2013-01-16 19:18:48 +00:00
|
|
|
(int)(ep - cp), cp);
|
2013-09-06 17:43:07 +00:00
|
|
|
if (s->display_comment_prefix)
|
|
|
|
color_fprintf_ln(s->fp, color(WT_STATUS_HEADER, s), "%c",
|
|
|
|
comment_line_char);
|
|
|
|
else
|
2017-04-27 09:01:05 +00:00
|
|
|
fputs("\n", s->fp);
|
2017-08-30 18:20:18 +00:00
|
|
|
strbuf_release(&sb);
|
2008-07-02 07:52:16 +00:00
|
|
|
}
|
|
|
|
|
2012-06-05 20:21:24 +00:00
|
|
|
static void show_merge_in_progress(struct wt_status *s,
|
2018-09-30 14:12:45 +00:00
|
|
|
const char *color)
|
2012-06-05 20:21:24 +00:00
|
|
|
{
|
|
|
|
if (has_unmerged(s)) {
|
|
|
|
status_printf_ln(s, color, _("You have unmerged paths."));
|
2016-07-21 12:58:37 +00:00
|
|
|
if (s->hints) {
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
2016-07-21 12:58:37 +00:00
|
|
|
_(" (fix conflicts and run \"git commit\")"));
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
2016-07-21 12:58:37 +00:00
|
|
|
_(" (use \"git merge --abort\" to abort the merge)"));
|
|
|
|
}
|
2012-06-05 20:21:24 +00:00
|
|
|
} else {
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("All conflicts fixed but you are still merging."));
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git commit\" to conclude merge)"));
|
|
|
|
}
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void show_am_in_progress(struct wt_status *s,
|
|
|
|
const char *color)
|
|
|
|
{
|
2021-12-09 07:25:55 +00:00
|
|
|
int am_empty_patch;
|
|
|
|
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are in the middle of an am session."));
|
2018-09-30 14:12:45 +00:00
|
|
|
if (s->state.am_empty_patch)
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("The current patch is empty."));
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints) {
|
2021-12-09 07:25:55 +00:00
|
|
|
am_empty_patch = s->state.am_empty_patch;
|
|
|
|
if (!am_empty_patch)
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
2013-06-26 20:06:41 +00:00
|
|
|
_(" (fix conflicts and then run \"git am --continue\")"));
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git am --skip\" to skip this patch)"));
|
2021-12-09 07:25:55 +00:00
|
|
|
if (am_empty_patch)
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git am --allow-empty\" to record this patch as an empty commit)"));
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git am --abort\" to restore the original branch)"));
|
|
|
|
}
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
|
|
|
|
2012-06-10 11:17:38 +00:00
|
|
|
static char *read_line_from_git_path(const char *filename)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2017-05-03 10:16:50 +00:00
|
|
|
FILE *fp = fopen_or_warn(git_path("%s", filename), "r");
|
|
|
|
|
2012-06-10 11:17:38 +00:00
|
|
|
if (!fp) {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-01-13 23:31:17 +00:00
|
|
|
strbuf_getline_lf(&buf, fp);
|
2012-06-10 11:17:38 +00:00
|
|
|
if (!fclose(fp)) {
|
|
|
|
return strbuf_detach(&buf, NULL);
|
|
|
|
} else {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int split_commit_in_progress(struct wt_status *s)
|
|
|
|
{
|
|
|
|
int split_in_progress = 0;
|
2017-05-04 13:56:44 +00:00
|
|
|
char *head, *orig_head, *rebase_amend, *rebase_orig_head;
|
2012-06-10 11:17:38 +00:00
|
|
|
|
2017-05-04 13:56:44 +00:00
|
|
|
if ((!s->amend && !s->nowarn && !s->workdir_dirty) ||
|
2012-06-10 11:17:38 +00:00
|
|
|
!s->branch || strcmp(s->branch, "HEAD"))
|
2017-05-04 13:56:44 +00:00
|
|
|
return 0;
|
2012-06-10 11:17:38 +00:00
|
|
|
|
2017-05-04 13:56:44 +00:00
|
|
|
head = read_line_from_git_path("HEAD");
|
|
|
|
orig_head = read_line_from_git_path("ORIG_HEAD");
|
|
|
|
rebase_amend = read_line_from_git_path("rebase-merge/amend");
|
|
|
|
rebase_orig_head = read_line_from_git_path("rebase-merge/orig-head");
|
2012-06-10 11:17:38 +00:00
|
|
|
|
2017-05-04 13:56:44 +00:00
|
|
|
if (!head || !orig_head || !rebase_amend || !rebase_orig_head)
|
|
|
|
; /* fall through, no split in progress */
|
|
|
|
else if (!strcmp(rebase_amend, rebase_orig_head))
|
|
|
|
split_in_progress = !!strcmp(head, rebase_amend);
|
|
|
|
else if (strcmp(orig_head, rebase_orig_head))
|
|
|
|
split_in_progress = 1;
|
2012-06-10 11:17:38 +00:00
|
|
|
|
|
|
|
free(head);
|
|
|
|
free(orig_head);
|
|
|
|
free(rebase_amend);
|
|
|
|
free(rebase_orig_head);
|
2017-05-04 13:56:44 +00:00
|
|
|
|
2012-06-10 11:17:38 +00:00
|
|
|
return split_in_progress;
|
|
|
|
}
|
|
|
|
|
2015-07-06 20:56:03 +00:00
|
|
|
/*
|
|
|
|
* Turn
|
|
|
|
* "pick d6a2f0303e897ec257dd0e0a39a5ccb709bc2047 some message"
|
|
|
|
* into
|
|
|
|
* "pick d6a2f03 some message"
|
|
|
|
*
|
|
|
|
* The function assumes that the line does not contain useless spaces
|
|
|
|
* before or after the command.
|
|
|
|
*/
|
2020-09-27 13:15:41 +00:00
|
|
|
static void abbrev_oid_in_line(struct strbuf *line)
|
2015-07-06 20:56:03 +00:00
|
|
|
{
|
|
|
|
struct strbuf **split;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (starts_with(line->buf, "exec ") ||
|
2019-05-10 20:23:14 +00:00
|
|
|
starts_with(line->buf, "x ") ||
|
|
|
|
starts_with(line->buf, "label ") ||
|
|
|
|
starts_with(line->buf, "l "))
|
2015-07-06 20:56:03 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
split = strbuf_split_max(line, ' ', 3);
|
|
|
|
if (split[0] && split[1]) {
|
2017-02-21 23:47:37 +00:00
|
|
|
struct object_id oid;
|
2015-07-06 20:56:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* strbuf_split_max left a space. Trim it and re-add
|
|
|
|
* it after abbreviation.
|
|
|
|
*/
|
|
|
|
strbuf_trim(split[1]);
|
2017-02-21 23:47:37 +00:00
|
|
|
if (!get_oid(split[1]->buf, &oid)) {
|
2015-07-06 20:56:03 +00:00
|
|
|
strbuf_reset(split[1]);
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
strbuf_add_unique_abbrev(split[1], &oid,
|
2016-10-08 15:38:47 +00:00
|
|
|
DEFAULT_ABBREV);
|
|
|
|
strbuf_addch(split[1], ' ');
|
2015-07-06 20:56:03 +00:00
|
|
|
strbuf_reset(line);
|
|
|
|
for (i = 0; split[i]; i++)
|
2016-07-19 18:36:29 +00:00
|
|
|
strbuf_addbuf(line, split[i]);
|
2015-07-06 20:56:03 +00:00
|
|
|
}
|
|
|
|
}
|
2016-04-01 00:35:44 +00:00
|
|
|
strbuf_list_free(split);
|
2015-07-06 20:56:03 +00:00
|
|
|
}
|
|
|
|
|
2017-01-26 16:08:41 +00:00
|
|
|
static int read_rebase_todolist(const char *fname, struct string_list *lines)
|
2015-07-06 20:56:03 +00:00
|
|
|
{
|
|
|
|
struct strbuf line = STRBUF_INIT;
|
|
|
|
FILE *f = fopen(git_path("%s", fname), "r");
|
|
|
|
|
2017-01-26 16:08:41 +00:00
|
|
|
if (!f) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
return -1;
|
2015-07-06 20:56:03 +00:00
|
|
|
die_errno("Could not open file %s for reading",
|
|
|
|
git_path("%s", fname));
|
2017-01-26 16:08:41 +00:00
|
|
|
}
|
2016-01-13 23:31:17 +00:00
|
|
|
while (!strbuf_getline_lf(&line, f)) {
|
2015-07-06 20:56:03 +00:00
|
|
|
if (line.len && line.buf[0] == comment_line_char)
|
|
|
|
continue;
|
|
|
|
strbuf_trim(&line);
|
|
|
|
if (!line.len)
|
|
|
|
continue;
|
2020-09-27 13:15:41 +00:00
|
|
|
abbrev_oid_in_line(&line);
|
2015-07-06 20:56:03 +00:00
|
|
|
string_list_append(lines, line.buf);
|
|
|
|
}
|
2017-05-04 13:55:52 +00:00
|
|
|
fclose(f);
|
2017-08-30 18:20:17 +00:00
|
|
|
strbuf_release(&line);
|
2017-01-26 16:08:41 +00:00
|
|
|
return 0;
|
2015-07-06 20:56:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void show_rebase_information(struct wt_status *s,
|
2018-09-30 14:12:45 +00:00
|
|
|
const char *color)
|
2015-07-06 20:56:03 +00:00
|
|
|
{
|
2018-09-30 14:12:45 +00:00
|
|
|
if (s->state.rebase_interactive_in_progress) {
|
2015-07-06 20:56:03 +00:00
|
|
|
int i;
|
|
|
|
int nr_lines_to_show = 2;
|
|
|
|
|
|
|
|
struct string_list have_done = STRING_LIST_INIT_DUP;
|
|
|
|
struct string_list yet_to_do = STRING_LIST_INIT_DUP;
|
|
|
|
|
|
|
|
read_rebase_todolist("rebase-merge/done", &have_done);
|
2017-01-26 16:08:41 +00:00
|
|
|
if (read_rebase_todolist("rebase-merge/git-rebase-todo",
|
|
|
|
&yet_to_do))
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("git-rebase-todo is missing."));
|
2015-07-06 20:56:03 +00:00
|
|
|
if (have_done.nr == 0)
|
|
|
|
status_printf_ln(s, color, _("No commands done."));
|
|
|
|
else {
|
|
|
|
status_printf_ln(s, color,
|
2022-03-07 15:27:08 +00:00
|
|
|
Q_("Last command done (%"PRIuMAX" command done):",
|
|
|
|
"Last commands done (%"PRIuMAX" commands done):",
|
2015-07-06 20:56:03 +00:00
|
|
|
have_done.nr),
|
2022-03-07 15:27:08 +00:00
|
|
|
(uintmax_t)have_done.nr);
|
2015-07-06 20:56:03 +00:00
|
|
|
for (i = (have_done.nr > nr_lines_to_show)
|
|
|
|
? have_done.nr - nr_lines_to_show : 0;
|
|
|
|
i < have_done.nr;
|
|
|
|
i++)
|
|
|
|
status_printf_ln(s, color, " %s", have_done.items[i].string);
|
|
|
|
if (have_done.nr > nr_lines_to_show && s->hints)
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (see more in file %s)"), git_path("rebase-merge/done"));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (yet_to_do.nr == 0)
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("No commands remaining."));
|
|
|
|
else {
|
|
|
|
status_printf_ln(s, color,
|
2022-03-07 15:27:08 +00:00
|
|
|
Q_("Next command to do (%"PRIuMAX" remaining command):",
|
|
|
|
"Next commands to do (%"PRIuMAX" remaining commands):",
|
2015-07-06 20:56:03 +00:00
|
|
|
yet_to_do.nr),
|
2022-03-07 15:27:08 +00:00
|
|
|
(uintmax_t)yet_to_do.nr);
|
2015-07-06 20:56:03 +00:00
|
|
|
for (i = 0; i < nr_lines_to_show && i < yet_to_do.nr; i++)
|
|
|
|
status_printf_ln(s, color, " %s", yet_to_do.items[i].string);
|
|
|
|
if (s->hints)
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git rebase --edit-todo\" to view and edit)"));
|
|
|
|
}
|
|
|
|
string_list_clear(&yet_to_do, 0);
|
|
|
|
string_list_clear(&have_done, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-30 13:01:12 +00:00
|
|
|
static void print_rebase_state(struct wt_status *s,
|
2018-09-30 14:12:45 +00:00
|
|
|
const char *color)
|
2015-06-30 13:01:12 +00:00
|
|
|
{
|
2018-09-30 14:12:45 +00:00
|
|
|
if (s->state.branch)
|
2015-06-30 13:01:12 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently rebasing branch '%s' on '%s'."),
|
2018-09-30 14:12:45 +00:00
|
|
|
s->state.branch,
|
|
|
|
s->state.onto);
|
2015-06-30 13:01:12 +00:00
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently rebasing."));
|
|
|
|
}
|
|
|
|
|
2012-06-05 20:21:24 +00:00
|
|
|
static void show_rebase_in_progress(struct wt_status *s,
|
2018-09-30 14:12:45 +00:00
|
|
|
const char *color)
|
2012-06-05 20:21:24 +00:00
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
2018-09-30 14:12:45 +00:00
|
|
|
show_rebase_information(s, color);
|
2012-06-05 20:21:24 +00:00
|
|
|
if (has_unmerged(s)) {
|
2018-09-30 14:12:45 +00:00
|
|
|
print_rebase_state(s, color);
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints) {
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (fix conflicts and then run \"git rebase --continue\")"));
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git rebase --skip\" to skip this patch)"));
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git rebase --abort\" to check out the original branch)"));
|
|
|
|
}
|
2018-09-30 14:12:45 +00:00
|
|
|
} else if (s->state.rebase_in_progress ||
|
2018-11-10 05:48:49 +00:00
|
|
|
!stat(git_path_merge_msg(s->repo), &st)) {
|
2018-09-30 14:12:45 +00:00
|
|
|
print_rebase_state(s, color);
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (all conflicts fixed: run \"git rebase --continue\")"));
|
2012-06-10 11:17:38 +00:00
|
|
|
} else if (split_commit_in_progress(s)) {
|
2018-09-30 14:12:45 +00:00
|
|
|
if (s->state.branch)
|
2013-02-03 05:53:27 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently splitting a commit while rebasing branch '%s' on '%s'."),
|
2018-09-30 14:12:45 +00:00
|
|
|
s->state.branch,
|
|
|
|
s->state.onto);
|
2013-02-03 05:53:27 +00:00
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently splitting a commit during a rebase."));
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2012-06-10 11:17:38 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (Once your working directory is clean, run \"git rebase --continue\")"));
|
2012-06-05 20:21:24 +00:00
|
|
|
} else {
|
2018-09-30 14:12:45 +00:00
|
|
|
if (s->state.branch)
|
2013-02-03 05:53:27 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently editing a commit while rebasing branch '%s' on '%s'."),
|
2018-09-30 14:12:45 +00:00
|
|
|
s->state.branch,
|
|
|
|
s->state.onto);
|
2013-02-03 05:53:27 +00:00
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently editing a commit during a rebase."));
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints && !s->amend) {
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git commit --amend\" to amend the current commit)"));
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git rebase --continue\" once you are satisfied with your changes)"));
|
|
|
|
}
|
|
|
|
}
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void show_cherry_pick_in_progress(struct wt_status *s,
|
2018-09-30 14:12:45 +00:00
|
|
|
const char *color)
|
2012-06-05 20:21:24 +00:00
|
|
|
{
|
2019-04-16 10:18:42 +00:00
|
|
|
if (is_null_oid(&s->state.cherry_pick_head_oid))
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("Cherry-pick currently in progress."));
|
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently cherry-picking commit %s."),
|
|
|
|
find_unique_abbrev(&s->state.cherry_pick_head_oid,
|
|
|
|
DEFAULT_ABBREV));
|
|
|
|
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints) {
|
2012-06-05 20:21:24 +00:00
|
|
|
if (has_unmerged(s))
|
|
|
|
status_printf_ln(s, color,
|
2013-06-17 04:28:26 +00:00
|
|
|
_(" (fix conflicts and run \"git cherry-pick --continue\")"));
|
2019-04-16 10:18:42 +00:00
|
|
|
else if (is_null_oid(&s->state.cherry_pick_head_oid))
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (run \"git cherry-pick --continue\" to continue)"));
|
2012-06-05 20:21:24 +00:00
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
2013-06-17 04:28:26 +00:00
|
|
|
_(" (all conflicts fixed: run \"git cherry-pick --continue\")"));
|
2019-08-27 04:45:41 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git cherry-pick --skip\" to skip this patch)"));
|
2013-06-17 04:28:26 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git cherry-pick --abort\" to cancel the cherry-pick operation)"));
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
|
|
|
|
2013-04-02 14:20:21 +00:00
|
|
|
static void show_revert_in_progress(struct wt_status *s,
|
2018-09-30 14:12:45 +00:00
|
|
|
const char *color)
|
2013-04-02 14:20:21 +00:00
|
|
|
{
|
2019-04-16 10:18:42 +00:00
|
|
|
if (is_null_oid(&s->state.revert_head_oid))
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("Revert currently in progress."));
|
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently reverting commit %s."),
|
|
|
|
find_unique_abbrev(&s->state.revert_head_oid,
|
|
|
|
DEFAULT_ABBREV));
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints) {
|
2013-04-02 14:20:21 +00:00
|
|
|
if (has_unmerged(s))
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (fix conflicts and run \"git revert --continue\")"));
|
2019-04-16 10:18:42 +00:00
|
|
|
else if (is_null_oid(&s->state.revert_head_oid))
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (run \"git revert --continue\" to continue)"));
|
2013-04-02 14:20:21 +00:00
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (all conflicts fixed: run \"git revert --continue\")"));
|
2019-08-27 04:45:41 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git revert --skip\" to skip this patch)"));
|
2013-04-02 14:20:21 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git revert --abort\" to cancel the revert operation)"));
|
|
|
|
}
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2013-04-02 14:20:21 +00:00
|
|
|
}
|
|
|
|
|
2012-06-05 20:21:24 +00:00
|
|
|
static void show_bisect_in_progress(struct wt_status *s,
|
2018-09-30 14:12:45 +00:00
|
|
|
const char *color)
|
2012-06-05 20:21:24 +00:00
|
|
|
{
|
2018-09-30 14:12:45 +00:00
|
|
|
if (s->state.branch)
|
2013-02-03 05:53:27 +00:00
|
|
|
status_printf_ln(s, color,
|
2013-03-23 03:52:44 +00:00
|
|
|
_("You are currently bisecting, started from branch '%s'."),
|
2018-09-30 14:12:45 +00:00
|
|
|
s->state.branch);
|
2013-02-03 05:53:27 +00:00
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently bisecting."));
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2012-06-05 20:21:24 +00:00
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (use \"git bisect reset\" to get back to the original branch)"));
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
|
|
|
|
2020-06-18 20:49:57 +00:00
|
|
|
static void show_sparse_checkout_in_use(struct wt_status *s,
|
|
|
|
const char *color)
|
|
|
|
{
|
|
|
|
if (s->state.sparse_checkout_percentage == SPARSE_CHECKOUT_DISABLED)
|
|
|
|
return;
|
|
|
|
|
2021-07-14 13:12:36 +00:00
|
|
|
if (s->state.sparse_checkout_percentage == SPARSE_CHECKOUT_SPARSE_INDEX)
|
|
|
|
status_printf_ln(s, color, _("You are in a sparse checkout."));
|
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are in a sparse checkout with %d%% of tracked files present."),
|
|
|
|
s->state.sparse_checkout_percentage);
|
2020-06-18 20:49:57 +00:00
|
|
|
wt_longstatus_print_trailer(s);
|
|
|
|
}
|
|
|
|
|
2013-02-03 05:53:27 +00:00
|
|
|
/*
|
|
|
|
* Extract branch information from rebase/bisect
|
|
|
|
*/
|
2016-04-22 13:01:31 +00:00
|
|
|
static char *get_branch(const struct worktree *wt, const char *path)
|
2013-02-03 05:53:27 +00:00
|
|
|
{
|
2013-03-16 02:12:36 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2017-02-21 23:47:37 +00:00
|
|
|
struct object_id oid;
|
2015-10-31 17:37:43 +00:00
|
|
|
const char *branch_name;
|
2013-02-03 05:53:27 +00:00
|
|
|
|
2016-04-22 13:01:31 +00:00
|
|
|
if (strbuf_read_file(&sb, worktree_git_path(wt, "%s", path), 0) <= 0)
|
2013-03-16 02:12:36 +00:00
|
|
|
goto got_nothing;
|
2013-02-03 05:53:27 +00:00
|
|
|
|
2015-01-28 17:57:35 +00:00
|
|
|
while (sb.len && sb.buf[sb.len - 1] == '\n')
|
2013-03-16 02:12:36 +00:00
|
|
|
strbuf_setlen(&sb, sb.len - 1);
|
|
|
|
if (!sb.len)
|
|
|
|
goto got_nothing;
|
2015-10-31 17:37:43 +00:00
|
|
|
if (skip_prefix(sb.buf, "refs/heads/", &branch_name))
|
|
|
|
strbuf_remove(&sb, 0, branch_name - sb.buf);
|
2013-11-30 20:55:40 +00:00
|
|
|
else if (starts_with(sb.buf, "refs/"))
|
2013-03-16 02:12:36 +00:00
|
|
|
;
|
2017-02-21 23:47:37 +00:00
|
|
|
else if (!get_oid_hex(sb.buf, &oid)) {
|
2013-03-16 02:12:36 +00:00
|
|
|
strbuf_reset(&sb);
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
strbuf_add_unique_abbrev(&sb, &oid, DEFAULT_ABBREV);
|
2013-03-16 02:12:36 +00:00
|
|
|
} else if (!strcmp(sb.buf, "detached HEAD")) /* rebase */
|
|
|
|
goto got_nothing;
|
2013-02-03 05:53:27 +00:00
|
|
|
else /* bisect */
|
2013-03-16 02:12:36 +00:00
|
|
|
;
|
|
|
|
return strbuf_detach(&sb, NULL);
|
|
|
|
|
|
|
|
got_nothing:
|
|
|
|
strbuf_release(&sb);
|
|
|
|
return NULL;
|
2013-02-03 05:53:27 +00:00
|
|
|
}
|
|
|
|
|
2013-03-13 11:42:52 +00:00
|
|
|
struct grab_1st_switch_cbdata {
|
|
|
|
struct strbuf buf;
|
2017-02-21 23:47:37 +00:00
|
|
|
struct object_id noid;
|
2013-03-13 11:42:52 +00:00
|
|
|
};
|
|
|
|
|
2017-02-21 23:47:32 +00:00
|
|
|
static int grab_1st_switch(struct object_id *ooid, struct object_id *noid,
|
2017-04-26 19:29:31 +00:00
|
|
|
const char *email, timestamp_t timestamp, int tz,
|
2013-03-13 11:42:52 +00:00
|
|
|
const char *message, void *cb_data)
|
2012-06-05 20:21:24 +00:00
|
|
|
{
|
2013-03-13 11:42:52 +00:00
|
|
|
struct grab_1st_switch_cbdata *cb = cb_data;
|
|
|
|
const char *target = NULL, *end;
|
2012-06-05 20:21:24 +00:00
|
|
|
|
2015-10-31 17:37:43 +00:00
|
|
|
if (!skip_prefix(message, "checkout: moving from ", &message))
|
2013-03-13 11:42:52 +00:00
|
|
|
return 0;
|
|
|
|
target = strstr(message, " to ");
|
|
|
|
if (!target)
|
|
|
|
return 0;
|
|
|
|
target += strlen(" to ");
|
|
|
|
strbuf_reset(&cb->buf);
|
2017-02-21 23:47:37 +00:00
|
|
|
oidcpy(&cb->noid, noid);
|
wt-status: correct and simplify check for detached HEAD
If a branch name is longer than four characters then memcmp() reads over
the end of the static string "HEAD". This causes the following test
failures with AddressSanitizer:
t3203-branch-output.sh (Wstat: 256 Tests: 18 Failed: 4)
Failed tests: 12, 15-17
Non-zero exit status: 1
t3412-rebase-root.sh (Wstat: 256 Tests: 31 Failed: 3)
Failed tests: 28-29, 31
Non-zero exit status: 1
t3507-cherry-pick-conflict.sh (Wstat: 256 Tests: 31 Failed: 4)
Failed tests: 14, 29-31
Non-zero exit status: 1
t3510-cherry-pick-sequence.sh (Wstat: 256 Tests: 39 Failed: 14)
Failed tests: 17, 22-26, 28-30, 34-35, 37-39
Non-zero exit status: 1
t3420-rebase-autostash.sh (Wstat: 256 Tests: 28 Failed: 4)
Failed tests: 24-27
Non-zero exit status: 1
t3404-rebase-interactive.sh (Wstat: 256 Tests: 91 Failed: 57)
Failed tests: 17, 19, 21-42, 44, 46-74, 77, 81-82
Non-zero exit status: 1
t3900-i18n-commit.sh (Wstat: 256 Tests: 34 Failed: 1)
Failed test: 34
Non-zero exit status: 1
t5407-post-rewrite-hook.sh (Wstat: 256 Tests: 14 Failed: 6)
Failed tests: 9-14
Non-zero exit status: 1
t7001-mv.sh (Wstat: 256 Tests: 46 Failed: 5)
Failed tests: 39-43
Non-zero exit status: 1
t7509-commit.sh (Wstat: 256 Tests: 12 Failed: 2)
Failed tests: 11-12
Non-zero exit status: 1
t7512-status-help.sh (Wstat: 256 Tests: 39 Failed: 35)
Failed tests: 5-39
Non-zero exit status: 1
t6030-bisect-porcelain.sh (Wstat: 256 Tests: 70 Failed: 1)
Failed test: 13
Non-zero exit status: 1
And if a branch is named "H", "HE", or "HEA" then the current if clause
erroneously considers it as matching "HEAD" because it only compares
up to the end of the branch name.
Fix that by doing the comparison using strcmp() and only after the
branch name is extracted. This way neither too less nor too many
characters are checked. While at it call strchrnul() to find the end
of the branch name instead of open-coding it.
Helped-by: Jeff King <peff@peff.net>
Signed-off-by: Rene Scharfe <l.s.r@web.de>
Signed-off-by: Jeff King <peff@peff.net>
2015-11-25 14:10:18 +00:00
|
|
|
end = strchrnul(target, '\n');
|
|
|
|
strbuf_add(&cb->buf, target, end - target);
|
|
|
|
if (!strcmp(cb->buf.buf, "HEAD")) {
|
2015-09-27 15:13:42 +00:00
|
|
|
/* HEAD is relative. Resolve it to the right reflog entry. */
|
wt-status: correct and simplify check for detached HEAD
If a branch name is longer than four characters then memcmp() reads over
the end of the static string "HEAD". This causes the following test
failures with AddressSanitizer:
t3203-branch-output.sh (Wstat: 256 Tests: 18 Failed: 4)
Failed tests: 12, 15-17
Non-zero exit status: 1
t3412-rebase-root.sh (Wstat: 256 Tests: 31 Failed: 3)
Failed tests: 28-29, 31
Non-zero exit status: 1
t3507-cherry-pick-conflict.sh (Wstat: 256 Tests: 31 Failed: 4)
Failed tests: 14, 29-31
Non-zero exit status: 1
t3510-cherry-pick-sequence.sh (Wstat: 256 Tests: 39 Failed: 14)
Failed tests: 17, 22-26, 28-30, 34-35, 37-39
Non-zero exit status: 1
t3420-rebase-autostash.sh (Wstat: 256 Tests: 28 Failed: 4)
Failed tests: 24-27
Non-zero exit status: 1
t3404-rebase-interactive.sh (Wstat: 256 Tests: 91 Failed: 57)
Failed tests: 17, 19, 21-42, 44, 46-74, 77, 81-82
Non-zero exit status: 1
t3900-i18n-commit.sh (Wstat: 256 Tests: 34 Failed: 1)
Failed test: 34
Non-zero exit status: 1
t5407-post-rewrite-hook.sh (Wstat: 256 Tests: 14 Failed: 6)
Failed tests: 9-14
Non-zero exit status: 1
t7001-mv.sh (Wstat: 256 Tests: 46 Failed: 5)
Failed tests: 39-43
Non-zero exit status: 1
t7509-commit.sh (Wstat: 256 Tests: 12 Failed: 2)
Failed tests: 11-12
Non-zero exit status: 1
t7512-status-help.sh (Wstat: 256 Tests: 39 Failed: 35)
Failed tests: 5-39
Non-zero exit status: 1
t6030-bisect-porcelain.sh (Wstat: 256 Tests: 70 Failed: 1)
Failed test: 13
Non-zero exit status: 1
And if a branch is named "H", "HE", or "HEA" then the current if clause
erroneously considers it as matching "HEAD" because it only compares
up to the end of the branch name.
Fix that by doing the comparison using strcmp() and only after the
branch name is extracted. This way neither too less nor too many
characters are checked. While at it call strchrnul() to find the end
of the branch name instead of open-coding it.
Helped-by: Jeff King <peff@peff.net>
Signed-off-by: Rene Scharfe <l.s.r@web.de>
Signed-off-by: Jeff King <peff@peff.net>
2015-11-25 14:10:18 +00:00
|
|
|
strbuf_reset(&cb->buf);
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
strbuf_add_unique_abbrev(&cb->buf, noid, DEFAULT_ABBREV);
|
2015-09-27 15:13:42 +00:00
|
|
|
}
|
2013-03-13 11:42:52 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-11-10 05:48:50 +00:00
|
|
|
static void wt_status_get_detached_from(struct repository *r,
|
|
|
|
struct wt_status_state *state)
|
2013-03-13 11:42:52 +00:00
|
|
|
{
|
|
|
|
struct grab_1st_switch_cbdata cb;
|
|
|
|
struct commit *commit;
|
2017-02-21 23:47:37 +00:00
|
|
|
struct object_id oid;
|
2013-03-13 11:42:52 +00:00
|
|
|
char *ref = NULL;
|
|
|
|
|
|
|
|
strbuf_init(&cb.buf, 0);
|
|
|
|
if (for_each_reflog_ent_reverse("HEAD", grab_1st_switch, &cb) <= 0) {
|
|
|
|
strbuf_release(&cb.buf);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-09-01 22:28:09 +00:00
|
|
|
if (dwim_ref(cb.buf.buf, cb.buf.len, &oid, &ref, 1) == 1 &&
|
2020-09-27 13:15:41 +00:00
|
|
|
/* oid is a commit? match without further lookup */
|
convert "oidcmp() == 0" to oideq()
Using the more restrictive oideq() should, in the long run,
give the compiler more opportunities to optimize these
callsites. For now, this conversion should be a complete
noop with respect to the generated code.
The result is also perhaps a little more readable, as it
avoids the "zero is equal" idiom. Since it's so prevalent in
C, I think seasoned programmers tend not to even notice it
anymore, but it can sometimes make for awkward double
negations (e.g., we can drop a few !!oidcmp() instances
here).
This patch was generated almost entirely by the included
coccinelle patch. This mechanical conversion should be
completely safe, because we check explicitly for cases where
oidcmp() is compared to 0, which is what oideq() is doing
under the hood. Note that we don't have to catch "!oidcmp()"
separately; coccinelle's standard isomorphisms make sure the
two are treated equivalently.
I say "almost" because I did hand-edit the coccinelle output
to fix up a few style violations (it mostly keeps the
original formatting, but sometimes unwraps long lines).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-28 21:22:40 +00:00
|
|
|
(oideq(&cb.noid, &oid) ||
|
2020-09-27 13:15:41 +00:00
|
|
|
/* perhaps oid is a tag, try to dereference to a commit */
|
2018-11-10 05:48:50 +00:00
|
|
|
((commit = lookup_commit_reference_gently(r, &oid, 1)) != NULL &&
|
convert "oidcmp() == 0" to oideq()
Using the more restrictive oideq() should, in the long run,
give the compiler more opportunities to optimize these
callsites. For now, this conversion should be a complete
noop with respect to the generated code.
The result is also perhaps a little more readable, as it
avoids the "zero is equal" idiom. Since it's so prevalent in
C, I think seasoned programmers tend not to even notice it
anymore, but it can sometimes make for awkward double
negations (e.g., we can drop a few !!oidcmp() instances
here).
This patch was generated almost entirely by the included
coccinelle patch. This mechanical conversion should be
completely safe, because we check explicitly for cases where
oidcmp() is compared to 0, which is what oideq() is doing
under the hood. Note that we don't have to catch "!oidcmp()"
separately; coccinelle's standard isomorphisms make sure the
two are treated equivalently.
I say "almost" because I did hand-edit the coccinelle output
to fix up a few style violations (it mostly keeps the
original formatting, but sometimes unwraps long lines).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-28 21:22:40 +00:00
|
|
|
oideq(&cb.noid, &commit->object.oid)))) {
|
2015-10-31 17:37:43 +00:00
|
|
|
const char *from = ref;
|
|
|
|
if (!skip_prefix(from, "refs/tags/", &from))
|
|
|
|
skip_prefix(from, "refs/remotes/", &from);
|
|
|
|
state->detached_from = xstrdup(from);
|
2013-03-13 11:42:52 +00:00
|
|
|
} else
|
|
|
|
state->detached_from =
|
2018-03-12 02:27:30 +00:00
|
|
|
xstrdup(find_unique_abbrev(&cb.noid, DEFAULT_ABBREV));
|
2018-03-12 02:27:29 +00:00
|
|
|
oidcpy(&state->detached_oid, &cb.noid);
|
2017-02-21 23:47:37 +00:00
|
|
|
state->detached_at = !get_oid("HEAD", &oid) &&
|
convert "oidcmp() == 0" to oideq()
Using the more restrictive oideq() should, in the long run,
give the compiler more opportunities to optimize these
callsites. For now, this conversion should be a complete
noop with respect to the generated code.
The result is also perhaps a little more readable, as it
avoids the "zero is equal" idiom. Since it's so prevalent in
C, I think seasoned programmers tend not to even notice it
anymore, but it can sometimes make for awkward double
negations (e.g., we can drop a few !!oidcmp() instances
here).
This patch was generated almost entirely by the included
coccinelle patch. This mechanical conversion should be
completely safe, because we check explicitly for cases where
oidcmp() is compared to 0, which is what oideq() is doing
under the hood. Note that we don't have to catch "!oidcmp()"
separately; coccinelle's standard isomorphisms make sure the
two are treated equivalently.
I say "almost" because I did hand-edit the coccinelle output
to fix up a few style violations (it mostly keeps the
original formatting, but sometimes unwraps long lines).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-28 21:22:40 +00:00
|
|
|
oideq(&oid, &state->detached_oid);
|
2013-03-13 11:42:52 +00:00
|
|
|
|
|
|
|
free(ref);
|
|
|
|
strbuf_release(&cb.buf);
|
|
|
|
}
|
|
|
|
|
2016-04-22 13:01:31 +00:00
|
|
|
int wt_status_check_rebase(const struct worktree *wt,
|
|
|
|
struct wt_status_state *state)
|
2012-06-05 20:21:24 +00:00
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
2016-04-22 13:01:31 +00:00
|
|
|
if (!stat(worktree_git_path(wt, "rebase-apply"), &st)) {
|
|
|
|
if (!stat(worktree_git_path(wt, "rebase-apply/applying"), &st)) {
|
2013-03-13 11:42:50 +00:00
|
|
|
state->am_in_progress = 1;
|
2016-04-22 13:01:31 +00:00
|
|
|
if (!stat(worktree_git_path(wt, "rebase-apply/patch"), &st) && !st.st_size)
|
2013-03-13 11:42:50 +00:00
|
|
|
state->am_empty_patch = 1;
|
2012-06-05 20:21:24 +00:00
|
|
|
} else {
|
2013-03-13 11:42:50 +00:00
|
|
|
state->rebase_in_progress = 1;
|
2016-04-22 13:01:31 +00:00
|
|
|
state->branch = get_branch(wt, "rebase-apply/head-name");
|
|
|
|
state->onto = get_branch(wt, "rebase-apply/onto");
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
2016-04-22 13:01:31 +00:00
|
|
|
} else if (!stat(worktree_git_path(wt, "rebase-merge"), &st)) {
|
|
|
|
if (!stat(worktree_git_path(wt, "rebase-merge/interactive"), &st))
|
2013-03-13 11:42:50 +00:00
|
|
|
state->rebase_interactive_in_progress = 1;
|
2012-06-05 20:21:24 +00:00
|
|
|
else
|
2013-03-13 11:42:50 +00:00
|
|
|
state->rebase_in_progress = 1;
|
2016-04-22 13:01:31 +00:00
|
|
|
state->branch = get_branch(wt, "rebase-merge/head-name");
|
|
|
|
state->onto = get_branch(wt, "rebase-merge/onto");
|
2016-04-22 13:01:30 +00:00
|
|
|
} else
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-04-22 13:01:34 +00:00
|
|
|
int wt_status_check_bisect(const struct worktree *wt,
|
|
|
|
struct wt_status_state *state)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (!stat(worktree_git_path(wt, "BISECT_LOG"), &st)) {
|
|
|
|
state->bisect_in_progress = 1;
|
|
|
|
state->branch = get_branch(wt, "BISECT_START");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-18 20:49:57 +00:00
|
|
|
static void wt_status_check_sparse_checkout(struct repository *r,
|
|
|
|
struct wt_status_state *state)
|
|
|
|
{
|
|
|
|
int skip_worktree = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!core_apply_sparse_checkout || r->index->cache_nr == 0) {
|
|
|
|
/*
|
|
|
|
* Don't compute percentage of checked out files if we
|
|
|
|
* aren't in a sparse checkout or would get division by 0.
|
|
|
|
*/
|
|
|
|
state->sparse_checkout_percentage = SPARSE_CHECKOUT_DISABLED;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-07-14 13:12:36 +00:00
|
|
|
if (r->index->sparse_index) {
|
|
|
|
state->sparse_checkout_percentage = SPARSE_CHECKOUT_SPARSE_INDEX;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-06-18 20:49:57 +00:00
|
|
|
for (i = 0; i < r->index->cache_nr; i++) {
|
|
|
|
struct cache_entry *ce = r->index->cache[i];
|
|
|
|
if (ce_skip_worktree(ce))
|
|
|
|
skip_worktree++;
|
|
|
|
}
|
|
|
|
|
|
|
|
state->sparse_checkout_percentage =
|
|
|
|
100 - (100 * skip_worktree)/r->index->cache_nr;
|
|
|
|
}
|
|
|
|
|
2018-11-10 05:48:50 +00:00
|
|
|
void wt_status_get_state(struct repository *r,
|
|
|
|
struct wt_status_state *state,
|
2016-04-22 13:01:30 +00:00
|
|
|
int get_detached_from)
|
|
|
|
{
|
|
|
|
struct stat st;
|
2017-02-21 23:47:37 +00:00
|
|
|
struct object_id oid;
|
2019-04-16 10:18:42 +00:00
|
|
|
enum replay_action action;
|
2016-04-22 13:01:30 +00:00
|
|
|
|
2018-11-10 05:48:50 +00:00
|
|
|
if (!stat(git_path_merge_head(r), &st)) {
|
2018-11-12 23:26:02 +00:00
|
|
|
wt_status_check_rebase(NULL, state);
|
2016-04-22 13:01:30 +00:00
|
|
|
state->merge_in_progress = 1;
|
2016-04-22 13:01:31 +00:00
|
|
|
} else if (wt_status_check_rebase(NULL, state)) {
|
2016-04-22 13:01:30 +00:00
|
|
|
; /* all set */
|
2020-08-21 16:59:35 +00:00
|
|
|
} else if (refs_ref_exists(get_main_ref_store(r), "CHERRY_PICK_HEAD") &&
|
|
|
|
!get_oid("CHERRY_PICK_HEAD", &oid)) {
|
2013-03-13 11:42:50 +00:00
|
|
|
state->cherry_pick_in_progress = 1;
|
2018-03-12 02:27:29 +00:00
|
|
|
oidcpy(&state->cherry_pick_head_oid, &oid);
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
2016-04-22 13:01:34 +00:00
|
|
|
wt_status_check_bisect(NULL, state);
|
2020-08-21 16:59:37 +00:00
|
|
|
if (refs_ref_exists(get_main_ref_store(r), "REVERT_HEAD") &&
|
2017-02-21 23:47:37 +00:00
|
|
|
!get_oid("REVERT_HEAD", &oid)) {
|
2013-04-02 14:20:21 +00:00
|
|
|
state->revert_in_progress = 1;
|
2018-03-12 02:27:29 +00:00
|
|
|
oidcpy(&state->revert_head_oid, &oid);
|
2013-04-02 14:20:21 +00:00
|
|
|
}
|
2019-04-16 10:18:42 +00:00
|
|
|
if (!sequencer_get_last_command(r, &action)) {
|
|
|
|
if (action == REPLAY_PICK) {
|
|
|
|
state->cherry_pick_in_progress = 1;
|
2021-04-26 01:02:56 +00:00
|
|
|
oidcpy(&state->cherry_pick_head_oid, null_oid());
|
2019-04-16 10:18:42 +00:00
|
|
|
} else {
|
|
|
|
state->revert_in_progress = 1;
|
2021-04-26 01:02:56 +00:00
|
|
|
oidcpy(&state->revert_head_oid, null_oid());
|
2019-04-16 10:18:42 +00:00
|
|
|
}
|
|
|
|
}
|
2013-03-13 11:42:52 +00:00
|
|
|
if (get_detached_from)
|
2018-11-10 05:48:50 +00:00
|
|
|
wt_status_get_detached_from(r, state);
|
2020-06-18 20:49:57 +00:00
|
|
|
wt_status_check_sparse_checkout(r, state);
|
2013-03-13 11:42:50 +00:00
|
|
|
}
|
|
|
|
|
2018-09-30 14:12:45 +00:00
|
|
|
static void wt_longstatus_print_state(struct wt_status *s)
|
2013-03-13 11:42:50 +00:00
|
|
|
{
|
|
|
|
const char *state_color = color(WT_STATUS_HEADER, s);
|
2018-09-30 14:12:45 +00:00
|
|
|
struct wt_status_state *state = &s->state;
|
|
|
|
|
2018-11-12 23:26:02 +00:00
|
|
|
if (state->merge_in_progress) {
|
|
|
|
if (state->rebase_interactive_in_progress) {
|
|
|
|
show_rebase_information(s, state_color);
|
|
|
|
fputs("\n", s->fp);
|
|
|
|
}
|
2018-09-30 14:12:45 +00:00
|
|
|
show_merge_in_progress(s, state_color);
|
2018-11-12 23:26:02 +00:00
|
|
|
} else if (state->am_in_progress)
|
2018-09-30 14:12:45 +00:00
|
|
|
show_am_in_progress(s, state_color);
|
2013-03-13 11:42:51 +00:00
|
|
|
else if (state->rebase_in_progress || state->rebase_interactive_in_progress)
|
2018-09-30 14:12:45 +00:00
|
|
|
show_rebase_in_progress(s, state_color);
|
2013-03-13 11:42:51 +00:00
|
|
|
else if (state->cherry_pick_in_progress)
|
2018-09-30 14:12:45 +00:00
|
|
|
show_cherry_pick_in_progress(s, state_color);
|
2013-04-02 14:20:21 +00:00
|
|
|
else if (state->revert_in_progress)
|
2018-09-30 14:12:45 +00:00
|
|
|
show_revert_in_progress(s, state_color);
|
2013-03-13 11:42:51 +00:00
|
|
|
if (state->bisect_in_progress)
|
2018-09-30 14:12:45 +00:00
|
|
|
show_bisect_in_progress(s, state_color);
|
2020-06-18 20:49:57 +00:00
|
|
|
|
|
|
|
if (state->sparse_checkout_percentage != SPARSE_CHECKOUT_DISABLED)
|
|
|
|
show_sparse_checkout_in_use(s, state_color);
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:27 +00:00
|
|
|
static void wt_longstatus_print(struct wt_status *s)
|
2006-09-08 08:05:34 +00:00
|
|
|
{
|
2010-11-17 23:40:05 +00:00
|
|
|
const char *branch_color = color(WT_STATUS_ONBRANCH, s);
|
|
|
|
const char *branch_status_color = color(WT_STATUS_HEADER, s);
|
2007-01-02 19:26:23 +00:00
|
|
|
|
2007-01-03 09:09:34 +00:00
|
|
|
if (s->branch) {
|
2011-02-22 23:42:13 +00:00
|
|
|
const char *on_what = _("On branch ");
|
2007-01-03 09:09:34 +00:00
|
|
|
const char *branch_name = s->branch;
|
2015-10-31 17:37:43 +00:00
|
|
|
if (!strcmp(branch_name, "HEAD")) {
|
2010-11-17 23:40:05 +00:00
|
|
|
branch_status_color = color(WT_STATUS_NOBRANCH, s);
|
2018-09-30 14:12:45 +00:00
|
|
|
if (s->state.rebase_in_progress ||
|
|
|
|
s->state.rebase_interactive_in_progress) {
|
|
|
|
if (s->state.rebase_interactive_in_progress)
|
2015-06-30 13:01:13 +00:00
|
|
|
on_what = _("interactive rebase in progress; onto ");
|
|
|
|
else
|
|
|
|
on_what = _("rebase in progress; onto ");
|
2018-09-30 14:12:45 +00:00
|
|
|
branch_name = s->state.onto;
|
|
|
|
} else if (s->state.detached_from) {
|
|
|
|
branch_name = s->state.detached_from;
|
|
|
|
if (s->state.detached_at)
|
branch: sort detached HEAD based on a flag
Change the ref-filter sorting of detached HEAD to check the
FILTER_REFS_DETACHED_HEAD flag, instead of relying on the ref
description filled-in by get_head_description() to start with "(",
which in turn we expect to ASCII-sort before any other reference.
For context, we'd like the detached line to appear first at the start
of "git branch -l", e.g.:
$ git branch -l
* (HEAD detached at <hash>)
master
This doesn't change that, but improves on a fix made in
28438e84e04 (ref-filter: sort detached HEAD lines firstly, 2019-06-18)
and gives the Chinese translation the ability to use its preferred
punctuation marks again.
In Chinese the fullwidth versions of punctuation like "()" are
typically written as (U+FF08 fullwidth left parenthesis), (U+FF09
fullwidth right parenthesis) instead[1]. This form is used in both
po/zh_{CN,TW}.po in most cases where "()" is translated in a string.
Aside from that improvement to the Chinese translation, it also just
makes for cleaner code that we mark any special cases in the ref_array
we're sorting with flags and make the sort function aware of them,
instead of piggy-backing on the general-case of strcmp() doing the
right thing.
As seen in the amended tests this made reverse sorting a bit more
consistent. Before this we'd sometimes sort this message in the
middle, now it's consistently at the beginning or end, depending on
whether we're doing a normal or reverse sort. Having it at the end
doesn't make much sense either, but at least it behaves consistently
now. A follow-up commit will make this behavior under reverse sorting
even better.
I'm removing the "TRANSLATORS" comments that were in the old code
while I'm at it. Those were added in d4919bb288e (ref-filter: move
get_head_description() from branch.c, 2017-01-10). I think it's
obvious from context, string and translation memory in typical
translation tools that these are the same or similar string.
1. https://en.wikipedia.org/wiki/Chinese_punctuation#Marks_similar_to_European_punctuation
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-01-07 09:51:52 +00:00
|
|
|
on_what = _("HEAD detached at ");
|
2013-03-13 11:42:52 +00:00
|
|
|
else
|
branch: sort detached HEAD based on a flag
Change the ref-filter sorting of detached HEAD to check the
FILTER_REFS_DETACHED_HEAD flag, instead of relying on the ref
description filled-in by get_head_description() to start with "(",
which in turn we expect to ASCII-sort before any other reference.
For context, we'd like the detached line to appear first at the start
of "git branch -l", e.g.:
$ git branch -l
* (HEAD detached at <hash>)
master
This doesn't change that, but improves on a fix made in
28438e84e04 (ref-filter: sort detached HEAD lines firstly, 2019-06-18)
and gives the Chinese translation the ability to use its preferred
punctuation marks again.
In Chinese the fullwidth versions of punctuation like "()" are
typically written as (U+FF08 fullwidth left parenthesis), (U+FF09
fullwidth right parenthesis) instead[1]. This form is used in both
po/zh_{CN,TW}.po in most cases where "()" is translated in a string.
Aside from that improvement to the Chinese translation, it also just
makes for cleaner code that we mark any special cases in the ref_array
we're sorting with flags and make the sort function aware of them,
instead of piggy-backing on the general-case of strcmp() doing the
right thing.
As seen in the amended tests this made reverse sorting a bit more
consistent. Before this we'd sometimes sort this message in the
middle, now it's consistently at the beginning or end, depending on
whether we're doing a normal or reverse sort. Having it at the end
doesn't make much sense either, but at least it behaves consistently
now. A follow-up commit will make this behavior under reverse sorting
even better.
I'm removing the "TRANSLATORS" comments that were in the old code
while I'm at it. Those were added in d4919bb288e (ref-filter: move
get_head_description() from branch.c, 2017-01-10). I think it's
obvious from context, string and translation memory in typical
translation tools that these are the same or similar string.
1. https://en.wikipedia.org/wiki/Chinese_punctuation#Marks_similar_to_European_punctuation
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-01-07 09:51:52 +00:00
|
|
|
on_what = _("HEAD detached from ");
|
2013-03-13 11:42:52 +00:00
|
|
|
} else {
|
|
|
|
branch_name = "";
|
|
|
|
on_what = _("Not currently on any branch.");
|
|
|
|
}
|
2015-10-31 17:37:43 +00:00
|
|
|
} else
|
|
|
|
skip_prefix(branch_name, "refs/heads/", &branch_name);
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf(s, color(WT_STATUS_HEADER, s), "%s", "");
|
2011-02-26 05:11:37 +00:00
|
|
|
status_printf_more(s, branch_status_color, "%s", on_what);
|
|
|
|
status_printf_more(s, branch_color, "%s\n", branch_name);
|
2008-07-02 07:52:16 +00:00
|
|
|
if (!s->is_initial)
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_tracking(s);
|
2007-01-03 09:09:34 +00:00
|
|
|
}
|
2006-09-08 08:05:34 +00:00
|
|
|
|
2018-09-30 14:12:45 +00:00
|
|
|
wt_longstatus_print_state(s);
|
2013-03-13 11:42:51 +00:00
|
|
|
|
2006-09-08 08:05:34 +00:00
|
|
|
if (s->is_initial) {
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf_ln(s, color(WT_STATUS_HEADER, s), "%s", "");
|
2017-06-21 18:16:14 +00:00
|
|
|
status_printf_ln(s, color(WT_STATUS_HEADER, s),
|
|
|
|
s->commit_template
|
|
|
|
? _("Initial commit")
|
|
|
|
: _("No commits yet"));
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf_ln(s, color(WT_STATUS_HEADER, s), "%s", "");
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_updated(s);
|
|
|
|
wt_longstatus_print_unmerged(s);
|
|
|
|
wt_longstatus_print_changed(s);
|
2010-06-25 14:56:47 +00:00
|
|
|
if (s->submodule_summary &&
|
|
|
|
(!s->ignore_submodule_arg ||
|
|
|
|
strcmp(s->ignore_submodule_arg, "all"))) {
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_submodule_summary(s, 0); /* staged */
|
|
|
|
wt_longstatus_print_submodule_summary(s, 1); /* unstaged */
|
2010-01-17 19:42:31 +00:00
|
|
|
}
|
2010-04-10 07:33:17 +00:00
|
|
|
if (s->show_untracked_files) {
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_other(s, &s->untracked, _("Untracked files"), "add");
|
status: add option to show ignored files differently
Teach the status command more flexibility in how ignored files are
reported. Currently, the reporting of ignored files and untracked
files are linked. You cannot control how ignored files are reported
independently of how untracked files are reported (i.e. `all` vs
`normal`). This makes it impossible to show untracked files with the
`all` option, but show ignored files with the `normal` option.
This work 1) adds the ability to control the reporting of ignored
files independently of untracked files and 2) introduces the concept
of status reporting ignored paths that explicitly match an ignored
pattern. There are 2 benefits to these changes: 1) if a consumer needs
all untracked files but not all ignored files, there is a performance
benefit to not scanning all contents of an ignored directory and 2)
returning ignored files that explicitly match a path allow a consumer
to make more informed decisions about when a status result might be
stale.
This commit implements --ignored=matching with --untracked-files=all.
The following commit will implement --ignored=matching with
--untracked=files=normal.
As an example of where this flexibility could be useful is that our
application (Visual Studio) runs the status command and presents the
output. It shows all untracked files individually (e.g. using the
'--untracked-files==all' option), and would like to know about which
paths are ignored. It uses information about ignored paths to make
decisions about when the status result might have changed.
Additionally, many projects place build output into directories inside
a repository's working directory (e.g. in "bin/" and "obj/"
directories). Normal usage is to explicitly ignore these 2 directory
names in the .gitignore file (rather than or in addition to the *.obj
pattern).If an application could know that these directories are
explicitly ignored, it could infer that all contents are ignored as
well and make better informed decisions about files in these
directories. It could infer that any changes under these paths would
not affect the output of status. Additionally, there can be a
significant performance benefit by avoiding scanning through ignored
directories.
When status is set to report matching ignored files, it has the
following behavior. Ignored files and directories that explicitly
match an exclude pattern are reported. If an ignored directory matches
an exclude pattern, then the path of the directory is returned. If a
directory does not match an exclude pattern, but all of its contents
are ignored, then the contained files are reported instead of the
directory.
Signed-off-by: Jameson Miller <jamill@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-30 17:21:37 +00:00
|
|
|
if (s->show_ignored_mode)
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_other(s, &s->ignored, _("Ignored files"), "add -f");
|
2021-08-23 10:44:00 +00:00
|
|
|
if (advice_enabled(ADVICE_STATUS_U_OPTION) && 2000 < s->untracked_in_ms) {
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf_ln(s, GIT_COLOR_NORMAL, "%s", "");
|
2013-03-13 12:59:16 +00:00
|
|
|
status_printf_ln(s, GIT_COLOR_NORMAL,
|
2013-04-12 03:53:01 +00:00
|
|
|
_("It took %.2f seconds to enumerate untracked files. 'status -uno'\n"
|
|
|
|
"may speed it up, but you have to be careful not to forget to add\n"
|
|
|
|
"new files yourself (see 'git help status')."),
|
|
|
|
s->untracked_in_ms / 1000.0);
|
2013-03-13 12:59:16 +00:00
|
|
|
}
|
2018-09-06 00:53:27 +00:00
|
|
|
} else if (s->committable)
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, GIT_COLOR_NORMAL, _("Untracked files not listed%s"),
|
2013-09-12 10:50:05 +00:00
|
|
|
s->hints
|
2011-02-22 23:42:13 +00:00
|
|
|
? _(" (use -u option to show untracked files)") : "");
|
2006-09-08 08:05:34 +00:00
|
|
|
|
2008-11-12 08:23:37 +00:00
|
|
|
if (s->verbose)
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_verbose(s);
|
2018-09-06 00:53:27 +00:00
|
|
|
if (!s->committable) {
|
2007-01-02 19:26:22 +00:00
|
|
|
if (s->amend)
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, GIT_COLOR_NORMAL, _("No changes"));
|
2007-12-13 03:09:16 +00:00
|
|
|
else if (s->nowarn)
|
|
|
|
; /* nothing */
|
2012-09-06 15:16:50 +00:00
|
|
|
else if (s->workdir_dirty) {
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, _("no changes added to commit "
|
|
|
|
"(use \"git add\" and/or "
|
|
|
|
"\"git commit -a\")\n"));
|
2012-09-06 15:16:50 +00:00
|
|
|
else
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, _("no changes added to "
|
|
|
|
"commit\n"));
|
2012-09-06 15:16:50 +00:00
|
|
|
} else if (s->untracked.nr) {
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, _("nothing added to commit but "
|
|
|
|
"untracked files present (use "
|
|
|
|
"\"git add\" to track)\n"));
|
2012-09-06 15:16:50 +00:00
|
|
|
else
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, _("nothing added to commit but "
|
|
|
|
"untracked files present\n"));
|
2012-09-06 15:16:50 +00:00
|
|
|
} else if (s->is_initial) {
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, _("nothing to commit (create/"
|
|
|
|
"copy files and use \"git "
|
|
|
|
"add\" to track)\n"));
|
2012-09-06 15:16:50 +00:00
|
|
|
else
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, _("nothing to commit\n"));
|
2012-09-06 15:16:50 +00:00
|
|
|
} else if (!s->show_untracked_files) {
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, _("nothing to commit (use -u to "
|
|
|
|
"show untracked files)\n"));
|
2012-09-06 15:16:50 +00:00
|
|
|
else
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, _("nothing to commit\n"));
|
2012-09-06 15:16:50 +00:00
|
|
|
} else
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, _("nothing to commit, working tree "
|
|
|
|
"clean\n"));
|
2007-01-02 19:26:22 +00:00
|
|
|
}
|
2017-06-17 22:30:51 +00:00
|
|
|
if(s->show_stash)
|
|
|
|
wt_longstatus_print_stash_summary(s);
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
2009-12-05 15:04:37 +00:00
|
|
|
|
2012-05-07 19:44:44 +00:00
|
|
|
static void wt_shortstatus_unmerged(struct string_list_item *it,
|
2009-12-05 15:04:37 +00:00
|
|
|
struct wt_status *s)
|
|
|
|
{
|
|
|
|
struct wt_status_change_data *d = it->util;
|
|
|
|
const char *how = "??";
|
|
|
|
|
|
|
|
switch (d->stagemask) {
|
|
|
|
case 1: how = "DD"; break; /* both deleted */
|
|
|
|
case 2: how = "AU"; break; /* added by us */
|
|
|
|
case 3: how = "UD"; break; /* deleted by them */
|
|
|
|
case 4: how = "UA"; break; /* added by them */
|
|
|
|
case 5: how = "DU"; break; /* deleted by us */
|
|
|
|
case 6: how = "AA"; break; /* both added */
|
|
|
|
case 7: how = "UU"; break; /* both modified */
|
|
|
|
}
|
2009-12-05 15:04:38 +00:00
|
|
|
color_fprintf(s->fp, color(WT_STATUS_UNMERGED, s), "%s", how);
|
2012-05-07 19:44:44 +00:00
|
|
|
if (s->null_termination) {
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, " %s%c", it->string, 0);
|
2009-12-05 15:04:37 +00:00
|
|
|
} else {
|
|
|
|
struct strbuf onebuf = STRBUF_INIT;
|
|
|
|
const char *one;
|
2020-09-10 17:01:57 +00:00
|
|
|
one = quote_path(it->string, s->prefix, &onebuf, QUOTE_PATH_QUOTE_SP);
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, " %s\n", one);
|
2009-12-05 15:04:37 +00:00
|
|
|
strbuf_release(&onebuf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-07 19:44:44 +00:00
|
|
|
static void wt_shortstatus_status(struct string_list_item *it,
|
2009-12-05 15:04:37 +00:00
|
|
|
struct wt_status *s)
|
|
|
|
{
|
|
|
|
struct wt_status_change_data *d = it->util;
|
|
|
|
|
2009-12-05 15:04:38 +00:00
|
|
|
if (d->index_status)
|
|
|
|
color_fprintf(s->fp, color(WT_STATUS_UPDATED, s), "%c", d->index_status);
|
|
|
|
else
|
2020-09-27 13:15:42 +00:00
|
|
|
fputc(' ', s->fp);
|
2009-12-05 15:04:38 +00:00
|
|
|
if (d->worktree_status)
|
|
|
|
color_fprintf(s->fp, color(WT_STATUS_CHANGED, s), "%c", d->worktree_status);
|
|
|
|
else
|
2020-09-27 13:15:42 +00:00
|
|
|
fputc(' ', s->fp);
|
|
|
|
fputc(' ', s->fp);
|
2012-05-07 19:44:44 +00:00
|
|
|
if (s->null_termination) {
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, "%s%c", it->string, 0);
|
2017-12-27 10:18:38 +00:00
|
|
|
if (d->rename_source)
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, "%s%c", d->rename_source, 0);
|
2009-12-05 15:04:37 +00:00
|
|
|
} else {
|
|
|
|
struct strbuf onebuf = STRBUF_INIT;
|
|
|
|
const char *one;
|
2017-12-27 10:18:38 +00:00
|
|
|
|
|
|
|
if (d->rename_source) {
|
2020-09-10 17:01:55 +00:00
|
|
|
one = quote_path(d->rename_source, s->prefix, &onebuf,
|
|
|
|
QUOTE_PATH_QUOTE_SP);
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, "%s -> ", one);
|
2009-12-05 15:04:37 +00:00
|
|
|
strbuf_release(&onebuf);
|
|
|
|
}
|
2020-09-10 17:01:55 +00:00
|
|
|
one = quote_path(it->string, s->prefix, &onebuf, QUOTE_PATH_QUOTE_SP);
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, "%s\n", one);
|
2009-12-05 15:04:37 +00:00
|
|
|
strbuf_release(&onebuf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-07 19:44:44 +00:00
|
|
|
static void wt_shortstatus_other(struct string_list_item *it,
|
2010-04-10 07:33:17 +00:00
|
|
|
struct wt_status *s, const char *sign)
|
2009-12-05 15:04:37 +00:00
|
|
|
{
|
2012-05-07 19:44:44 +00:00
|
|
|
if (s->null_termination) {
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, "%s %s%c", sign, it->string, 0);
|
2009-12-05 15:04:37 +00:00
|
|
|
} else {
|
|
|
|
struct strbuf onebuf = STRBUF_INIT;
|
|
|
|
const char *one;
|
2020-09-10 17:01:57 +00:00
|
|
|
one = quote_path(it->string, s->prefix, &onebuf, QUOTE_PATH_QUOTE_SP);
|
2010-05-02 05:05:14 +00:00
|
|
|
color_fprintf(s->fp, color(WT_STATUS_UNTRACKED, s), "%s", sign);
|
2020-09-27 13:15:42 +00:00
|
|
|
fprintf(s->fp, " %s\n", one);
|
2009-12-05 15:04:37 +00:00
|
|
|
strbuf_release(&onebuf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-25 13:45:51 +00:00
|
|
|
static void wt_shortstatus_print_tracking(struct wt_status *s)
|
|
|
|
{
|
|
|
|
struct branch *branch;
|
|
|
|
const char *header_color = color(WT_STATUS_HEADER, s);
|
|
|
|
const char *branch_color_local = color(WT_STATUS_LOCAL_BRANCH, s);
|
|
|
|
const char *branch_color_remote = color(WT_STATUS_REMOTE_BRANCH, s);
|
|
|
|
|
|
|
|
const char *base;
|
2017-07-08 10:51:01 +00:00
|
|
|
char *short_base;
|
2010-05-25 13:45:51 +00:00
|
|
|
const char *branch_name;
|
2018-01-09 18:50:17 +00:00
|
|
|
int num_ours, num_theirs, sti;
|
branch: report invalid tracking branch as gone
Command "git branch -vv" will report tracking branches, but invalid
tracking branches are also reported. This is because the function
stat_tracking_info() can not distinguish invalid tracking branch
from other cases which it would not like to report, such as
there is no upstream settings at all, or nothing is changed between
one branch and its upstream.
Junio suggested missing upstream should be reported [1] like:
$ git branch -v -v
master e67ac84 initial
* topic 3fc0f2a [topicbase: gone] topic
$ git status
# On branch topic
# Your branch is based on 'topicbase', but the upstream is gone.
# (use "git branch --unset-upstream" to fixup)
...
$ git status -b -s
## topic...topicbase [gone]
...
In order to do like that, we need to distinguish these three cases
(i.e. no tracking, with configured but no longer valid tracking, and
with tracking) in function stat_tracking_info(). So the refactored
function stat_tracking_info() has three return values: -1 (with "gone"
base), 0 (no base), and 1 (with base).
If the caller does not like to report tracking info when nothing
changed between the branch and its upstream, simply checks if
num_theirs and num_ours are both 0.
[1]: http://thread.gmane.org/gmane.comp.version-control.git/231830/focus=232288
Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-26 07:02:48 +00:00
|
|
|
int upstream_is_gone = 0;
|
2010-05-25 13:45:51 +00:00
|
|
|
|
|
|
|
color_fprintf(s->fp, color(WT_STATUS_HEADER, s), "## ");
|
|
|
|
|
|
|
|
if (!s->branch)
|
|
|
|
return;
|
|
|
|
branch_name = s->branch;
|
|
|
|
|
2017-03-14 16:02:02 +00:00
|
|
|
#define LABEL(string) (s->no_gettext ? (string) : _(string))
|
|
|
|
|
2010-05-25 13:45:51 +00:00
|
|
|
if (s->is_initial)
|
2017-06-21 18:16:14 +00:00
|
|
|
color_fprintf(s->fp, header_color, LABEL(N_("No commits yet on ")));
|
branch: report invalid tracking branch as gone
Command "git branch -vv" will report tracking branches, but invalid
tracking branches are also reported. This is because the function
stat_tracking_info() can not distinguish invalid tracking branch
from other cases which it would not like to report, such as
there is no upstream settings at all, or nothing is changed between
one branch and its upstream.
Junio suggested missing upstream should be reported [1] like:
$ git branch -v -v
master e67ac84 initial
* topic 3fc0f2a [topicbase: gone] topic
$ git status
# On branch topic
# Your branch is based on 'topicbase', but the upstream is gone.
# (use "git branch --unset-upstream" to fixup)
...
$ git status -b -s
## topic...topicbase [gone]
...
In order to do like that, we need to distinguish these three cases
(i.e. no tracking, with configured but no longer valid tracking, and
with tracking) in function stat_tracking_info(). So the refactored
function stat_tracking_info() has three return values: -1 (with "gone"
base), 0 (no base), and 1 (with base).
If the caller does not like to report tracking info when nothing
changed between the branch and its upstream, simply checks if
num_theirs and num_ours are both 0.
[1]: http://thread.gmane.org/gmane.comp.version-control.git/231830/focus=232288
Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-26 07:02:48 +00:00
|
|
|
|
2015-10-31 17:36:35 +00:00
|
|
|
if (!strcmp(s->branch, "HEAD")) {
|
|
|
|
color_fprintf(s->fp, color(WT_STATUS_NOBRANCH, s), "%s",
|
2017-03-14 16:02:02 +00:00
|
|
|
LABEL(N_("HEAD (no branch)")));
|
2015-10-31 17:36:35 +00:00
|
|
|
goto conclude;
|
|
|
|
}
|
|
|
|
|
2015-10-31 17:37:43 +00:00
|
|
|
skip_prefix(branch_name, "refs/heads/", &branch_name);
|
2010-05-25 13:45:51 +00:00
|
|
|
|
2015-10-31 17:37:12 +00:00
|
|
|
branch = branch_get(branch_name);
|
branch: report invalid tracking branch as gone
Command "git branch -vv" will report tracking branches, but invalid
tracking branches are also reported. This is because the function
stat_tracking_info() can not distinguish invalid tracking branch
from other cases which it would not like to report, such as
there is no upstream settings at all, or nothing is changed between
one branch and its upstream.
Junio suggested missing upstream should be reported [1] like:
$ git branch -v -v
master e67ac84 initial
* topic 3fc0f2a [topicbase: gone] topic
$ git status
# On branch topic
# Your branch is based on 'topicbase', but the upstream is gone.
# (use "git branch --unset-upstream" to fixup)
...
$ git status -b -s
## topic...topicbase [gone]
...
In order to do like that, we need to distinguish these three cases
(i.e. no tracking, with configured but no longer valid tracking, and
with tracking) in function stat_tracking_info(). So the refactored
function stat_tracking_info() has three return values: -1 (with "gone"
base), 0 (no base), and 1 (with base).
If the caller does not like to report tracking info when nothing
changed between the branch and its upstream, simply checks if
num_theirs and num_ours are both 0.
[1]: http://thread.gmane.org/gmane.comp.version-control.git/231830/focus=232288
Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-26 07:02:48 +00:00
|
|
|
|
|
|
|
color_fprintf(s->fp, branch_color_local, "%s", branch_name);
|
|
|
|
|
2018-01-09 18:50:17 +00:00
|
|
|
sti = stat_tracking_info(branch, &num_ours, &num_theirs, &base,
|
2019-04-16 12:16:46 +00:00
|
|
|
0, s->ahead_behind_flags);
|
2018-01-09 18:50:17 +00:00
|
|
|
if (sti < 0) {
|
2015-10-31 17:36:01 +00:00
|
|
|
if (!base)
|
|
|
|
goto conclude;
|
2015-05-22 00:49:11 +00:00
|
|
|
|
branch: report invalid tracking branch as gone
Command "git branch -vv" will report tracking branches, but invalid
tracking branches are also reported. This is because the function
stat_tracking_info() can not distinguish invalid tracking branch
from other cases which it would not like to report, such as
there is no upstream settings at all, or nothing is changed between
one branch and its upstream.
Junio suggested missing upstream should be reported [1] like:
$ git branch -v -v
master e67ac84 initial
* topic 3fc0f2a [topicbase: gone] topic
$ git status
# On branch topic
# Your branch is based on 'topicbase', but the upstream is gone.
# (use "git branch --unset-upstream" to fixup)
...
$ git status -b -s
## topic...topicbase [gone]
...
In order to do like that, we need to distinguish these three cases
(i.e. no tracking, with configured but no longer valid tracking, and
with tracking) in function stat_tracking_info(). So the refactored
function stat_tracking_info() has three return values: -1 (with "gone"
base), 0 (no base), and 1 (with base).
If the caller does not like to report tracking info when nothing
changed between the branch and its upstream, simply checks if
num_theirs and num_ours are both 0.
[1]: http://thread.gmane.org/gmane.comp.version-control.git/231830/focus=232288
Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-26 07:02:48 +00:00
|
|
|
upstream_is_gone = 1;
|
2010-05-25 13:45:51 +00:00
|
|
|
}
|
|
|
|
|
2017-07-08 10:51:01 +00:00
|
|
|
short_base = shorten_unambiguous_ref(base, 0);
|
2010-05-25 13:45:51 +00:00
|
|
|
color_fprintf(s->fp, header_color, "...");
|
2017-07-08 10:51:01 +00:00
|
|
|
color_fprintf(s->fp, branch_color_remote, "%s", short_base);
|
|
|
|
free(short_base);
|
2010-05-25 13:45:51 +00:00
|
|
|
|
2018-01-09 18:50:17 +00:00
|
|
|
if (!upstream_is_gone && !sti)
|
2015-10-31 17:36:01 +00:00
|
|
|
goto conclude;
|
2013-08-26 07:02:49 +00:00
|
|
|
|
2010-05-25 13:45:51 +00:00
|
|
|
color_fprintf(s->fp, header_color, " [");
|
branch: report invalid tracking branch as gone
Command "git branch -vv" will report tracking branches, but invalid
tracking branches are also reported. This is because the function
stat_tracking_info() can not distinguish invalid tracking branch
from other cases which it would not like to report, such as
there is no upstream settings at all, or nothing is changed between
one branch and its upstream.
Junio suggested missing upstream should be reported [1] like:
$ git branch -v -v
master e67ac84 initial
* topic 3fc0f2a [topicbase: gone] topic
$ git status
# On branch topic
# Your branch is based on 'topicbase', but the upstream is gone.
# (use "git branch --unset-upstream" to fixup)
...
$ git status -b -s
## topic...topicbase [gone]
...
In order to do like that, we need to distinguish these three cases
(i.e. no tracking, with configured but no longer valid tracking, and
with tracking) in function stat_tracking_info(). So the refactored
function stat_tracking_info() has three return values: -1 (with "gone"
base), 0 (no base), and 1 (with base).
If the caller does not like to report tracking info when nothing
changed between the branch and its upstream, simply checks if
num_theirs and num_ours are both 0.
[1]: http://thread.gmane.org/gmane.comp.version-control.git/231830/focus=232288
Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-26 07:02:48 +00:00
|
|
|
if (upstream_is_gone) {
|
2014-03-20 12:12:41 +00:00
|
|
|
color_fprintf(s->fp, header_color, LABEL(N_("gone")));
|
2018-01-09 18:50:17 +00:00
|
|
|
} else if (s->ahead_behind_flags == AHEAD_BEHIND_QUICK) {
|
|
|
|
color_fprintf(s->fp, header_color, LABEL(N_("different")));
|
branch: report invalid tracking branch as gone
Command "git branch -vv" will report tracking branches, but invalid
tracking branches are also reported. This is because the function
stat_tracking_info() can not distinguish invalid tracking branch
from other cases which it would not like to report, such as
there is no upstream settings at all, or nothing is changed between
one branch and its upstream.
Junio suggested missing upstream should be reported [1] like:
$ git branch -v -v
master e67ac84 initial
* topic 3fc0f2a [topicbase: gone] topic
$ git status
# On branch topic
# Your branch is based on 'topicbase', but the upstream is gone.
# (use "git branch --unset-upstream" to fixup)
...
$ git status -b -s
## topic...topicbase [gone]
...
In order to do like that, we need to distinguish these three cases
(i.e. no tracking, with configured but no longer valid tracking, and
with tracking) in function stat_tracking_info(). So the refactored
function stat_tracking_info() has three return values: -1 (with "gone"
base), 0 (no base), and 1 (with base).
If the caller does not like to report tracking info when nothing
changed between the branch and its upstream, simply checks if
num_theirs and num_ours are both 0.
[1]: http://thread.gmane.org/gmane.comp.version-control.git/231830/focus=232288
Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-08-26 07:02:48 +00:00
|
|
|
} else if (!num_ours) {
|
2014-03-20 12:12:41 +00:00
|
|
|
color_fprintf(s->fp, header_color, LABEL(N_("behind ")));
|
2010-05-25 13:45:51 +00:00
|
|
|
color_fprintf(s->fp, branch_color_remote, "%d", num_theirs);
|
|
|
|
} else if (!num_theirs) {
|
2016-03-14 15:30:33 +00:00
|
|
|
color_fprintf(s->fp, header_color, LABEL(N_("ahead ")));
|
2010-05-25 13:45:51 +00:00
|
|
|
color_fprintf(s->fp, branch_color_local, "%d", num_ours);
|
|
|
|
} else {
|
2016-03-14 15:30:33 +00:00
|
|
|
color_fprintf(s->fp, header_color, LABEL(N_("ahead ")));
|
2010-05-25 13:45:51 +00:00
|
|
|
color_fprintf(s->fp, branch_color_local, "%d", num_ours);
|
2014-03-20 12:12:41 +00:00
|
|
|
color_fprintf(s->fp, header_color, ", %s", LABEL(N_("behind ")));
|
2010-05-25 13:45:51 +00:00
|
|
|
color_fprintf(s->fp, branch_color_remote, "%d", num_theirs);
|
|
|
|
}
|
|
|
|
|
2012-05-07 21:02:18 +00:00
|
|
|
color_fprintf(s->fp, header_color, "]");
|
2015-10-31 17:36:01 +00:00
|
|
|
conclude:
|
2012-05-07 21:02:18 +00:00
|
|
|
fputc(s->null_termination ? '\0' : '\n', s->fp);
|
2010-05-25 13:45:51 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:27 +00:00
|
|
|
static void wt_shortstatus_print(struct wt_status *s)
|
2009-12-05 15:04:37 +00:00
|
|
|
{
|
2017-03-16 21:36:19 +00:00
|
|
|
struct string_list_item *it;
|
2010-05-25 13:45:51 +00:00
|
|
|
|
2012-05-07 21:09:04 +00:00
|
|
|
if (s->show_branch)
|
2010-05-25 13:45:51 +00:00
|
|
|
wt_shortstatus_print_tracking(s);
|
|
|
|
|
2017-03-16 21:36:19 +00:00
|
|
|
for_each_string_list_item(it, &s->change) {
|
|
|
|
struct wt_status_change_data *d = it->util;
|
2009-12-05 15:04:37 +00:00
|
|
|
|
|
|
|
if (d->stagemask)
|
2012-05-07 19:44:44 +00:00
|
|
|
wt_shortstatus_unmerged(it, s);
|
2009-12-05 15:04:37 +00:00
|
|
|
else
|
2012-05-07 19:44:44 +00:00
|
|
|
wt_shortstatus_status(it, s);
|
2009-12-05 15:04:37 +00:00
|
|
|
}
|
2017-03-16 21:36:19 +00:00
|
|
|
for_each_string_list_item(it, &s->untracked)
|
2012-05-07 19:44:44 +00:00
|
|
|
wt_shortstatus_other(it, s, "??");
|
2010-04-10 07:33:17 +00:00
|
|
|
|
2017-03-16 21:36:19 +00:00
|
|
|
for_each_string_list_item(it, &s->ignored)
|
2012-05-07 19:44:44 +00:00
|
|
|
wt_shortstatus_other(it, s, "!!");
|
2009-12-05 15:04:37 +00:00
|
|
|
}
|
2009-12-07 05:17:15 +00:00
|
|
|
|
2016-08-05 22:00:27 +00:00
|
|
|
static void wt_porcelain_print(struct wt_status *s)
|
2009-12-07 05:17:15 +00:00
|
|
|
{
|
|
|
|
s->use_color = 0;
|
2009-12-07 05:26:25 +00:00
|
|
|
s->relative_paths = 0;
|
|
|
|
s->prefix = NULL;
|
2014-03-20 12:12:41 +00:00
|
|
|
s->no_gettext = 1;
|
2012-05-07 21:09:04 +00:00
|
|
|
wt_shortstatus_print(s);
|
2009-12-07 05:17:15 +00:00
|
|
|
}
|
2016-08-05 22:00:27 +00:00
|
|
|
|
2016-08-11 14:45:59 +00:00
|
|
|
/*
|
|
|
|
* Print branch information for porcelain v2 output. These lines
|
|
|
|
* are printed when the '--branch' parameter is given.
|
|
|
|
*
|
|
|
|
* # branch.oid <commit><eol>
|
|
|
|
* # branch.head <head><eol>
|
|
|
|
* [# branch.upstream <upstream><eol>
|
|
|
|
* [# branch.ab +<ahead> -<behind><eol>]]
|
|
|
|
*
|
2020-07-28 20:45:38 +00:00
|
|
|
* <commit> ::= the current commit hash or the literal
|
2016-08-11 14:45:59 +00:00
|
|
|
* "(initial)" to indicate an initialized repo
|
|
|
|
* with no commits.
|
|
|
|
*
|
|
|
|
* <head> ::= <branch_name> the current branch name or
|
|
|
|
* "(detached)" literal when detached head or
|
|
|
|
* "(unknown)" when something is wrong.
|
|
|
|
*
|
|
|
|
* <upstream> ::= the upstream branch name, when set.
|
|
|
|
*
|
2018-01-09 18:50:16 +00:00
|
|
|
* <ahead> ::= integer ahead value or '?'.
|
2016-08-11 14:45:59 +00:00
|
|
|
*
|
2018-01-09 18:50:16 +00:00
|
|
|
* <behind> ::= integer behind value or '?'.
|
2016-08-11 14:45:59 +00:00
|
|
|
*
|
|
|
|
* The end-of-line is defined by the -z flag.
|
|
|
|
*
|
|
|
|
* <eol> ::= NUL when -z,
|
|
|
|
* LF when NOT -z.
|
|
|
|
*
|
2018-01-09 18:50:16 +00:00
|
|
|
* When an upstream is set and present, the 'branch.ab' line will
|
|
|
|
* be printed with the ahead/behind counts for the branch and the
|
|
|
|
* upstream. When AHEAD_BEHIND_QUICK is requested and the branches
|
|
|
|
* are different, '?' will be substituted for the actual count.
|
2016-08-11 14:45:59 +00:00
|
|
|
*/
|
|
|
|
static void wt_porcelain_v2_print_tracking(struct wt_status *s)
|
|
|
|
{
|
|
|
|
struct branch *branch;
|
|
|
|
const char *base;
|
|
|
|
const char *branch_name;
|
|
|
|
int ab_info, nr_ahead, nr_behind;
|
|
|
|
char eol = s->null_termination ? '\0' : '\n';
|
|
|
|
|
|
|
|
fprintf(s->fp, "# branch.oid %s%c",
|
2019-08-18 20:04:21 +00:00
|
|
|
(s->is_initial ? "(initial)" : oid_to_hex(&s->oid_commit)),
|
2016-08-11 14:45:59 +00:00
|
|
|
eol);
|
|
|
|
|
|
|
|
if (!s->branch)
|
|
|
|
fprintf(s->fp, "# branch.head %s%c", "(unknown)", eol);
|
|
|
|
else {
|
|
|
|
if (!strcmp(s->branch, "HEAD")) {
|
|
|
|
fprintf(s->fp, "# branch.head %s%c", "(detached)", eol);
|
|
|
|
|
2018-09-30 14:12:45 +00:00
|
|
|
if (s->state.rebase_in_progress ||
|
|
|
|
s->state.rebase_interactive_in_progress)
|
|
|
|
branch_name = s->state.onto;
|
|
|
|
else if (s->state.detached_from)
|
|
|
|
branch_name = s->state.detached_from;
|
2016-08-11 14:45:59 +00:00
|
|
|
else
|
|
|
|
branch_name = "";
|
|
|
|
} else {
|
|
|
|
branch_name = NULL;
|
|
|
|
skip_prefix(s->branch, "refs/heads/", &branch_name);
|
|
|
|
|
|
|
|
fprintf(s->fp, "# branch.head %s%c", branch_name, eol);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Lookup stats on the upstream tracking branch, if set. */
|
|
|
|
branch = branch_get(branch_name);
|
|
|
|
base = NULL;
|
2018-01-09 18:50:16 +00:00
|
|
|
ab_info = stat_tracking_info(branch, &nr_ahead, &nr_behind,
|
2019-04-16 12:16:46 +00:00
|
|
|
&base, 0, s->ahead_behind_flags);
|
2016-08-11 14:45:59 +00:00
|
|
|
if (base) {
|
|
|
|
base = shorten_unambiguous_ref(base, 0);
|
|
|
|
fprintf(s->fp, "# branch.upstream %s%c", base, eol);
|
|
|
|
free((char *)base);
|
|
|
|
|
2018-01-09 18:50:16 +00:00
|
|
|
if (ab_info > 0) {
|
|
|
|
/* different */
|
|
|
|
if (nr_ahead || nr_behind)
|
|
|
|
fprintf(s->fp, "# branch.ab +%d -%d%c",
|
|
|
|
nr_ahead, nr_behind, eol);
|
|
|
|
else
|
|
|
|
fprintf(s->fp, "# branch.ab +? -?%c",
|
|
|
|
eol);
|
|
|
|
} else if (!ab_info) {
|
|
|
|
/* same */
|
|
|
|
fprintf(s->fp, "# branch.ab +0 -0%c", eol);
|
|
|
|
}
|
2016-08-11 14:45:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-21 22:25:32 +00:00
|
|
|
/*
|
|
|
|
* Print the stash count in a porcelain-friendly format
|
|
|
|
*/
|
|
|
|
static void wt_porcelain_v2_print_stash(struct wt_status *s)
|
|
|
|
{
|
|
|
|
int stash_count = count_stash_entries();
|
|
|
|
char eol = s->null_termination ? '\0' : '\n';
|
|
|
|
|
|
|
|
if (stash_count > 0)
|
|
|
|
fprintf(s->fp, "# stash %d%c", stash_count, eol);
|
|
|
|
}
|
|
|
|
|
2016-08-11 14:45:58 +00:00
|
|
|
/*
|
|
|
|
* Convert various submodule status values into a
|
|
|
|
* fixed-length string of characters in the buffer provided.
|
|
|
|
*/
|
|
|
|
static void wt_porcelain_v2_submodule_state(
|
|
|
|
struct wt_status_change_data *d,
|
|
|
|
char sub[5])
|
|
|
|
{
|
|
|
|
if (S_ISGITLINK(d->mode_head) ||
|
|
|
|
S_ISGITLINK(d->mode_index) ||
|
|
|
|
S_ISGITLINK(d->mode_worktree)) {
|
|
|
|
sub[0] = 'S';
|
|
|
|
sub[1] = d->new_submodule_commits ? 'C' : '.';
|
|
|
|
sub[2] = (d->dirty_submodule & DIRTY_SUBMODULE_MODIFIED) ? 'M' : '.';
|
|
|
|
sub[3] = (d->dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) ? 'U' : '.';
|
|
|
|
} else {
|
|
|
|
sub[0] = 'N';
|
|
|
|
sub[1] = '.';
|
|
|
|
sub[2] = '.';
|
|
|
|
sub[3] = '.';
|
|
|
|
}
|
|
|
|
sub[4] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fix-up changed entries before we print them.
|
|
|
|
*/
|
2019-05-09 21:30:19 +00:00
|
|
|
static void wt_porcelain_v2_fix_up_changed(struct string_list_item *it)
|
2016-08-11 14:45:58 +00:00
|
|
|
{
|
|
|
|
struct wt_status_change_data *d = it->util;
|
|
|
|
|
|
|
|
if (!d->index_status) {
|
|
|
|
/*
|
|
|
|
* This entry is unchanged in the index (relative to the head).
|
|
|
|
* Therefore, the collect_updated_cb was never called for this
|
|
|
|
* entry (during the head-vs-index scan) and so the head column
|
|
|
|
* fields were never set.
|
|
|
|
*
|
|
|
|
* We must have data for the index column (from the
|
|
|
|
* index-vs-worktree scan (otherwise, this entry should not be
|
|
|
|
* in the list of changes)).
|
|
|
|
*
|
|
|
|
* Copy index column fields to the head column, so that our
|
|
|
|
* output looks complete.
|
|
|
|
*/
|
|
|
|
assert(d->mode_head == 0);
|
|
|
|
d->mode_head = d->mode_index;
|
|
|
|
oidcpy(&d->oid_head, &d->oid_index);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!d->worktree_status) {
|
|
|
|
/*
|
|
|
|
* This entry is unchanged in the worktree (relative to the index).
|
|
|
|
* Therefore, the collect_changed_cb was never called for this entry
|
|
|
|
* (during the index-vs-worktree scan) and so the worktree column
|
|
|
|
* fields were never set.
|
|
|
|
*
|
|
|
|
* We must have data for the index column (from the head-vs-index
|
|
|
|
* scan).
|
|
|
|
*
|
|
|
|
* Copy the index column fields to the worktree column so that
|
|
|
|
* our output looks complete.
|
|
|
|
*
|
|
|
|
* Note that we only have a mode field in the worktree column
|
|
|
|
* because the scan code tries really hard to not have to compute it.
|
|
|
|
*/
|
|
|
|
assert(d->mode_worktree == 0);
|
|
|
|
d->mode_worktree = d->mode_index;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print porcelain v2 info for tracked entries with changes.
|
|
|
|
*/
|
|
|
|
static void wt_porcelain_v2_print_changed_entry(
|
|
|
|
struct string_list_item *it,
|
|
|
|
struct wt_status *s)
|
|
|
|
{
|
|
|
|
struct wt_status_change_data *d = it->util;
|
2017-12-27 10:18:38 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct strbuf buf_from = STRBUF_INIT;
|
|
|
|
const char *path = NULL;
|
|
|
|
const char *path_from = NULL;
|
2016-08-11 14:45:58 +00:00
|
|
|
char key[3];
|
|
|
|
char submodule_token[5];
|
|
|
|
char sep_char, eol_char;
|
|
|
|
|
2019-05-09 21:30:19 +00:00
|
|
|
wt_porcelain_v2_fix_up_changed(it);
|
2016-08-11 14:45:58 +00:00
|
|
|
wt_porcelain_v2_submodule_state(d, submodule_token);
|
|
|
|
|
|
|
|
key[0] = d->index_status ? d->index_status : '.';
|
|
|
|
key[1] = d->worktree_status ? d->worktree_status : '.';
|
|
|
|
key[2] = 0;
|
|
|
|
|
|
|
|
if (s->null_termination) {
|
|
|
|
/*
|
|
|
|
* In -z mode, we DO NOT C-quote pathnames. Current path is ALWAYS first.
|
|
|
|
* A single NUL character separates them.
|
|
|
|
*/
|
|
|
|
sep_char = '\0';
|
|
|
|
eol_char = '\0';
|
2017-12-27 10:18:38 +00:00
|
|
|
path = it->string;
|
|
|
|
path_from = d->rename_source;
|
2016-08-11 14:45:58 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Path(s) are C-quoted if necessary. Current path is ALWAYS first.
|
|
|
|
* The source path is only present when necessary.
|
|
|
|
* A single TAB separates them (because paths can contain spaces
|
|
|
|
* which are not escaped and C-quoting does escape TAB characters).
|
|
|
|
*/
|
|
|
|
sep_char = '\t';
|
|
|
|
eol_char = '\n';
|
2020-09-10 17:01:54 +00:00
|
|
|
path = quote_path(it->string, s->prefix, &buf, 0);
|
2017-12-27 10:18:38 +00:00
|
|
|
if (d->rename_source)
|
2020-09-10 17:01:54 +00:00
|
|
|
path_from = quote_path(d->rename_source, s->prefix, &buf_from, 0);
|
2016-08-11 14:45:58 +00:00
|
|
|
}
|
|
|
|
|
2017-12-27 10:18:38 +00:00
|
|
|
if (path_from)
|
2016-08-11 14:45:58 +00:00
|
|
|
fprintf(s->fp, "2 %s %s %06o %06o %06o %s %s %c%d %s%c%s%c",
|
|
|
|
key, submodule_token,
|
|
|
|
d->mode_head, d->mode_index, d->mode_worktree,
|
|
|
|
oid_to_hex(&d->oid_head), oid_to_hex(&d->oid_index),
|
2017-12-27 10:18:38 +00:00
|
|
|
d->rename_status, d->rename_score,
|
|
|
|
path, sep_char, path_from, eol_char);
|
2016-08-11 14:45:58 +00:00
|
|
|
else
|
|
|
|
fprintf(s->fp, "1 %s %s %06o %06o %06o %s %s %s%c",
|
|
|
|
key, submodule_token,
|
|
|
|
d->mode_head, d->mode_index, d->mode_worktree,
|
|
|
|
oid_to_hex(&d->oid_head), oid_to_hex(&d->oid_index),
|
2017-12-27 10:18:38 +00:00
|
|
|
path, eol_char);
|
2016-08-11 14:45:58 +00:00
|
|
|
|
2017-12-27 10:18:38 +00:00
|
|
|
strbuf_release(&buf);
|
|
|
|
strbuf_release(&buf_from);
|
2016-08-11 14:45:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print porcelain v2 status info for unmerged entries.
|
|
|
|
*/
|
|
|
|
static void wt_porcelain_v2_print_unmerged_entry(
|
|
|
|
struct string_list_item *it,
|
|
|
|
struct wt_status *s)
|
|
|
|
{
|
|
|
|
struct wt_status_change_data *d = it->util;
|
2018-11-10 05:48:49 +00:00
|
|
|
struct index_state *istate = s->repo->index;
|
2016-08-11 14:45:58 +00:00
|
|
|
const struct cache_entry *ce;
|
|
|
|
struct strbuf buf_index = STRBUF_INIT;
|
|
|
|
const char *path_index = NULL;
|
|
|
|
int pos, stage, sum;
|
|
|
|
struct {
|
|
|
|
int mode;
|
|
|
|
struct object_id oid;
|
|
|
|
} stages[3];
|
|
|
|
char *key;
|
|
|
|
char submodule_token[5];
|
|
|
|
char unmerged_prefix = 'u';
|
|
|
|
char eol_char = s->null_termination ? '\0' : '\n';
|
|
|
|
|
|
|
|
wt_porcelain_v2_submodule_state(d, submodule_token);
|
|
|
|
|
|
|
|
switch (d->stagemask) {
|
|
|
|
case 1: key = "DD"; break; /* both deleted */
|
|
|
|
case 2: key = "AU"; break; /* added by us */
|
|
|
|
case 3: key = "UD"; break; /* deleted by them */
|
|
|
|
case 4: key = "UA"; break; /* added by them */
|
|
|
|
case 5: key = "DU"; break; /* deleted by us */
|
|
|
|
case 6: key = "AA"; break; /* both added */
|
|
|
|
case 7: key = "UU"; break; /* both modified */
|
|
|
|
default:
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("unhandled unmerged status %x", d->stagemask);
|
2016-08-11 14:45:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disregard d.aux.porcelain_v2 data that we accumulated
|
|
|
|
* for the head and index columns during the scans and
|
|
|
|
* replace with the actual stage data.
|
|
|
|
*
|
|
|
|
* Note that this is a last-one-wins for each the individual
|
|
|
|
* stage [123] columns in the event of multiple cache entries
|
|
|
|
* for same stage.
|
|
|
|
*/
|
|
|
|
memset(stages, 0, sizeof(stages));
|
|
|
|
sum = 0;
|
2018-11-10 05:48:49 +00:00
|
|
|
pos = index_name_pos(istate, it->string, strlen(it->string));
|
2016-08-11 14:45:58 +00:00
|
|
|
assert(pos < 0);
|
|
|
|
pos = -pos-1;
|
2018-11-10 05:48:49 +00:00
|
|
|
while (pos < istate->cache_nr) {
|
|
|
|
ce = istate->cache[pos++];
|
2016-08-11 14:45:58 +00:00
|
|
|
stage = ce_stage(ce);
|
|
|
|
if (strcmp(ce->name, it->string) || !stage)
|
|
|
|
break;
|
|
|
|
stages[stage - 1].mode = ce->ce_mode;
|
2017-01-28 22:03:06 +00:00
|
|
|
oidcpy(&stages[stage - 1].oid, &ce->oid);
|
2016-08-11 14:45:58 +00:00
|
|
|
sum |= (1 << (stage - 1));
|
|
|
|
}
|
|
|
|
if (sum != d->stagemask)
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("observed stagemask 0x%x != expected stagemask 0x%x", sum, d->stagemask);
|
2016-08-11 14:45:58 +00:00
|
|
|
|
|
|
|
if (s->null_termination)
|
|
|
|
path_index = it->string;
|
|
|
|
else
|
2020-09-10 17:01:54 +00:00
|
|
|
path_index = quote_path(it->string, s->prefix, &buf_index, 0);
|
2016-08-11 14:45:58 +00:00
|
|
|
|
|
|
|
fprintf(s->fp, "%c %s %s %06o %06o %06o %06o %s %s %s %s%c",
|
|
|
|
unmerged_prefix, key, submodule_token,
|
|
|
|
stages[0].mode, /* stage 1 */
|
|
|
|
stages[1].mode, /* stage 2 */
|
|
|
|
stages[2].mode, /* stage 3 */
|
|
|
|
d->mode_worktree,
|
|
|
|
oid_to_hex(&stages[0].oid), /* stage 1 */
|
|
|
|
oid_to_hex(&stages[1].oid), /* stage 2 */
|
|
|
|
oid_to_hex(&stages[2].oid), /* stage 3 */
|
|
|
|
path_index,
|
|
|
|
eol_char);
|
|
|
|
|
|
|
|
strbuf_release(&buf_index);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print porcelain V2 status info for untracked and ignored entries.
|
|
|
|
*/
|
|
|
|
static void wt_porcelain_v2_print_other(
|
|
|
|
struct string_list_item *it,
|
|
|
|
struct wt_status *s,
|
|
|
|
char prefix)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
const char *path;
|
|
|
|
char eol_char;
|
|
|
|
|
|
|
|
if (s->null_termination) {
|
|
|
|
path = it->string;
|
|
|
|
eol_char = '\0';
|
|
|
|
} else {
|
2020-09-10 17:01:54 +00:00
|
|
|
path = quote_path(it->string, s->prefix, &buf, 0);
|
2016-08-11 14:45:58 +00:00
|
|
|
eol_char = '\n';
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(s->fp, "%c %s%c", prefix, path, eol_char);
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print porcelain V2 status.
|
|
|
|
*
|
2016-08-11 14:45:59 +00:00
|
|
|
* [<v2_branch>]
|
2016-08-11 14:45:58 +00:00
|
|
|
* [<v2_changed_items>]*
|
|
|
|
* [<v2_unmerged_items>]*
|
|
|
|
* [<v2_untracked_items>]*
|
|
|
|
* [<v2_ignored_items>]*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void wt_porcelain_v2_print(struct wt_status *s)
|
|
|
|
{
|
|
|
|
struct wt_status_change_data *d;
|
|
|
|
struct string_list_item *it;
|
|
|
|
int i;
|
|
|
|
|
2016-08-11 14:45:59 +00:00
|
|
|
if (s->show_branch)
|
|
|
|
wt_porcelain_v2_print_tracking(s);
|
|
|
|
|
2021-10-21 22:25:32 +00:00
|
|
|
if (s->show_stash)
|
|
|
|
wt_porcelain_v2_print_stash(s);
|
|
|
|
|
2016-08-11 14:45:58 +00:00
|
|
|
for (i = 0; i < s->change.nr; i++) {
|
|
|
|
it = &(s->change.items[i]);
|
|
|
|
d = it->util;
|
|
|
|
if (!d->stagemask)
|
|
|
|
wt_porcelain_v2_print_changed_entry(it, s);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < s->change.nr; i++) {
|
|
|
|
it = &(s->change.items[i]);
|
|
|
|
d = it->util;
|
|
|
|
if (d->stagemask)
|
|
|
|
wt_porcelain_v2_print_unmerged_entry(it, s);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < s->untracked.nr; i++) {
|
|
|
|
it = &(s->untracked.items[i]);
|
|
|
|
wt_porcelain_v2_print_other(it, s, '?');
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < s->ignored.nr; i++) {
|
|
|
|
it = &(s->ignored.items[i]);
|
|
|
|
wt_porcelain_v2_print_other(it, s, '!');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:27 +00:00
|
|
|
void wt_status_print(struct wt_status *s)
|
|
|
|
{
|
2019-02-22 22:25:03 +00:00
|
|
|
trace2_data_intmax("status", s->repo, "count/changed", s->change.nr);
|
|
|
|
trace2_data_intmax("status", s->repo, "count/untracked",
|
|
|
|
s->untracked.nr);
|
|
|
|
trace2_data_intmax("status", s->repo, "count/ignored", s->ignored.nr);
|
|
|
|
|
|
|
|
trace2_region_enter("status", "print", s->repo);
|
|
|
|
|
2016-08-05 22:00:27 +00:00
|
|
|
switch (s->status_format) {
|
|
|
|
case STATUS_FORMAT_SHORT:
|
|
|
|
wt_shortstatus_print(s);
|
|
|
|
break;
|
|
|
|
case STATUS_FORMAT_PORCELAIN:
|
|
|
|
wt_porcelain_print(s);
|
|
|
|
break;
|
2016-08-11 14:45:57 +00:00
|
|
|
case STATUS_FORMAT_PORCELAIN_V2:
|
2016-08-11 14:45:58 +00:00
|
|
|
wt_porcelain_v2_print(s);
|
2016-08-11 14:45:57 +00:00
|
|
|
break;
|
2016-08-05 22:00:27 +00:00
|
|
|
case STATUS_FORMAT_UNSPECIFIED:
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("finalize_deferred_config() should have been called");
|
2016-08-05 22:00:27 +00:00
|
|
|
break;
|
|
|
|
case STATUS_FORMAT_NONE:
|
|
|
|
case STATUS_FORMAT_LONG:
|
|
|
|
wt_longstatus_print(s);
|
|
|
|
break;
|
|
|
|
}
|
2019-02-22 22:25:03 +00:00
|
|
|
|
|
|
|
trace2_region_leave("status", "print", s->repo);
|
2016-08-05 22:00:27 +00:00
|
|
|
}
|
2016-10-07 16:08:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns 1 if there are unstaged changes, 0 otherwise.
|
|
|
|
*/
|
2018-11-10 05:48:49 +00:00
|
|
|
int has_unstaged_changes(struct repository *r, int ignore_submodules)
|
2016-10-07 16:08:38 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev_info;
|
|
|
|
int result;
|
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
repo_init_revisions(r, &rev_info, NULL);
|
2017-11-06 22:08:19 +00:00
|
|
|
if (ignore_submodules) {
|
2017-10-31 18:19:11 +00:00
|
|
|
rev_info.diffopt.flags.ignore_submodules = 1;
|
2017-11-15 03:14:30 +00:00
|
|
|
rev_info.diffopt.flags.override_submodule_config = 1;
|
2017-11-06 22:08:19 +00:00
|
|
|
}
|
2017-10-31 18:19:11 +00:00
|
|
|
rev_info.diffopt.flags.quick = 1;
|
2016-10-07 16:08:38 +00:00
|
|
|
diff_setup_done(&rev_info.diffopt);
|
|
|
|
result = run_diff_files(&rev_info, 0);
|
revision.[ch]: provide and start using a release_revisions()
The users of the revision.[ch] API's "struct rev_info" are a major
source of memory leaks in the test suite under SANITIZE=leak, which in
turn adds a lot of noise when trying to mark up tests with
"TEST_PASSES_SANITIZE_LEAK=true".
The users of that API are largely one-shot, e.g. "git rev-list" or
"git log", or the "git checkout" and "git stash" being modified here
For these callers freeing the memory is arguably a waste of time, but
in many cases they've actually been trying to free the memory, and
just doing that in a buggy manner.
Let's provide a release_revisions() function for these users, and
start migrating them over per the plan outlined in [1]. Right now this
only handles the "pending" member of the struct, but more will be
added in subsequent commits.
Even though we only clear the "pending" member now, let's not leave a
trap in code like the pre-image of index_differs_from(), where we'd
start doing the wrong thing as soon as the release_revisions() learned
to clear its "diffopt". I.e. we need to call release_revisions() after
we've inspected any state in "struct rev_info".
This leaves in place e.g. clear_pathspec(&rev.prune_data) in
stash_working_tree() in builtin/stash.c, subsequent commits will teach
release_revisions() to free "prune_data" and other members that in
some cases are individually cleared by users of "struct rev_info" by
reaching into its members. Those subsequent commits will remove the
relevant calls to e.g. clear_pathspec().
We avoid amending code in index_differs_from() in diff-lib.c as well
as wt_status_collect_changes_index(), has_unstaged_changes() and
has_uncommitted_changes() in wt-status.c in a way that assumes that we
are already clearing the "diffopt" member. That will be handled in a
subsequent commit.
1. https://lore.kernel.org/git/87a6k8daeu.fsf@evledraar.gmail.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-04-13 20:01:35 +00:00
|
|
|
release_revisions(&rev_info);
|
2016-10-07 16:08:38 +00:00
|
|
|
return diff_result_code(&rev_info.diffopt, result);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns 1 if there are uncommitted changes, 0 otherwise.
|
|
|
|
*/
|
2018-11-10 05:48:49 +00:00
|
|
|
int has_uncommitted_changes(struct repository *r,
|
|
|
|
int ignore_submodules)
|
2016-10-07 16:08:38 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev_info;
|
|
|
|
int result;
|
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
if (is_index_unborn(r->index))
|
2016-10-07 16:08:38 +00:00
|
|
|
return 0;
|
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
repo_init_revisions(r, &rev_info, NULL);
|
2016-10-07 16:09:00 +00:00
|
|
|
if (ignore_submodules)
|
2017-10-31 18:19:11 +00:00
|
|
|
rev_info.diffopt.flags.ignore_submodules = 1;
|
|
|
|
rev_info.diffopt.flags.quick = 1;
|
has_uncommitted_changes(): fall back to empty tree
If has_uncommitted_changes() can't resolve HEAD (e.g.,
because it's unborn or corrupt), then we end up calling
run_diff_index() with an empty revs.pending array. This
causes a segfault, as run_diff_index() blindly looks at the
first pending item.
Fixing this raises a question of fault: should
run_diff_index() handle this case, or is the caller wrong to
pass an empty pending list?
Looking at the other callers of run_diff_index(), they
handle this in one of three ways:
- they resolve the object themselves, and avoid doing the
diff if it's not valid
- they resolve the object themselves, and fall back to the
empty tree
- they use setup_revisions(), which will die() if the
object isn't valid
Since this is the only broken caller, that argues that the
fix should go there. Falling back to the empty tree makes
sense here, as we'd claim uncommitted changes if and only if
the index is non-empty. This may be a little funny in the
case of corruption (the corrupt HEAD probably _isn't_
empty), but:
- we don't actually know the reason here that HEAD didn't
resolve (the much more likely case is that we have an
unborn HEAD, in which case the empty tree comparison is
the right thing)
- this matches how other code, like "git diff", behaves
While we're thinking about it, let's add an assertion to
run_diff_index(). It should always be passed a single
object, and as this bug shows, it's easy to get it wrong
(and an assertion is easier to hunt down than a segfault, or
a quietly ignored extra tree).
Reported-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-11 14:14:06 +00:00
|
|
|
|
2016-10-07 16:08:38 +00:00
|
|
|
add_head_to_pending(&rev_info);
|
has_uncommitted_changes(): fall back to empty tree
If has_uncommitted_changes() can't resolve HEAD (e.g.,
because it's unborn or corrupt), then we end up calling
run_diff_index() with an empty revs.pending array. This
causes a segfault, as run_diff_index() blindly looks at the
first pending item.
Fixing this raises a question of fault: should
run_diff_index() handle this case, or is the caller wrong to
pass an empty pending list?
Looking at the other callers of run_diff_index(), they
handle this in one of three ways:
- they resolve the object themselves, and avoid doing the
diff if it's not valid
- they resolve the object themselves, and fall back to the
empty tree
- they use setup_revisions(), which will die() if the
object isn't valid
Since this is the only broken caller, that argues that the
fix should go there. Falling back to the empty tree makes
sense here, as we'd claim uncommitted changes if and only if
the index is non-empty. This may be a little funny in the
case of corruption (the corrupt HEAD probably _isn't_
empty), but:
- we don't actually know the reason here that HEAD didn't
resolve (the much more likely case is that we have an
unborn HEAD, in which case the empty tree comparison is
the right thing)
- this matches how other code, like "git diff", behaves
While we're thinking about it, let's add an assertion to
run_diff_index(). It should always be passed a single
object, and as this bug shows, it's easy to get it wrong
(and an assertion is easier to hunt down than a segfault, or
a quietly ignored extra tree).
Reported-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-11 14:14:06 +00:00
|
|
|
if (!rev_info.pending.nr) {
|
|
|
|
/*
|
|
|
|
* We have no head (or it's corrupt); use the empty tree,
|
|
|
|
* which will complain if the index is non-empty.
|
|
|
|
*/
|
2018-11-10 05:48:49 +00:00
|
|
|
struct tree *tree = lookup_tree(r, the_hash_algo->empty_tree);
|
has_uncommitted_changes(): fall back to empty tree
If has_uncommitted_changes() can't resolve HEAD (e.g.,
because it's unborn or corrupt), then we end up calling
run_diff_index() with an empty revs.pending array. This
causes a segfault, as run_diff_index() blindly looks at the
first pending item.
Fixing this raises a question of fault: should
run_diff_index() handle this case, or is the caller wrong to
pass an empty pending list?
Looking at the other callers of run_diff_index(), they
handle this in one of three ways:
- they resolve the object themselves, and avoid doing the
diff if it's not valid
- they resolve the object themselves, and fall back to the
empty tree
- they use setup_revisions(), which will die() if the
object isn't valid
Since this is the only broken caller, that argues that the
fix should go there. Falling back to the empty tree makes
sense here, as we'd claim uncommitted changes if and only if
the index is non-empty. This may be a little funny in the
case of corruption (the corrupt HEAD probably _isn't_
empty), but:
- we don't actually know the reason here that HEAD didn't
resolve (the much more likely case is that we have an
unborn HEAD, in which case the empty tree comparison is
the right thing)
- this matches how other code, like "git diff", behaves
While we're thinking about it, let's add an assertion to
run_diff_index(). It should always be passed a single
object, and as this bug shows, it's easy to get it wrong
(and an assertion is easier to hunt down than a segfault, or
a quietly ignored extra tree).
Reported-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-07-11 14:14:06 +00:00
|
|
|
add_pending_object(&rev_info, &tree->object, "");
|
|
|
|
}
|
|
|
|
|
2016-10-07 16:08:38 +00:00
|
|
|
diff_setup_done(&rev_info.diffopt);
|
|
|
|
result = run_diff_index(&rev_info, 1);
|
revision.[ch]: provide and start using a release_revisions()
The users of the revision.[ch] API's "struct rev_info" are a major
source of memory leaks in the test suite under SANITIZE=leak, which in
turn adds a lot of noise when trying to mark up tests with
"TEST_PASSES_SANITIZE_LEAK=true".
The users of that API are largely one-shot, e.g. "git rev-list" or
"git log", or the "git checkout" and "git stash" being modified here
For these callers freeing the memory is arguably a waste of time, but
in many cases they've actually been trying to free the memory, and
just doing that in a buggy manner.
Let's provide a release_revisions() function for these users, and
start migrating them over per the plan outlined in [1]. Right now this
only handles the "pending" member of the struct, but more will be
added in subsequent commits.
Even though we only clear the "pending" member now, let's not leave a
trap in code like the pre-image of index_differs_from(), where we'd
start doing the wrong thing as soon as the release_revisions() learned
to clear its "diffopt". I.e. we need to call release_revisions() after
we've inspected any state in "struct rev_info".
This leaves in place e.g. clear_pathspec(&rev.prune_data) in
stash_working_tree() in builtin/stash.c, subsequent commits will teach
release_revisions() to free "prune_data" and other members that in
some cases are individually cleared by users of "struct rev_info" by
reaching into its members. Those subsequent commits will remove the
relevant calls to e.g. clear_pathspec().
We avoid amending code in index_differs_from() in diff-lib.c as well
as wt_status_collect_changes_index(), has_unstaged_changes() and
has_uncommitted_changes() in wt-status.c in a way that assumes that we
are already clearing the "diffopt" member. That will be handled in a
subsequent commit.
1. https://lore.kernel.org/git/87a6k8daeu.fsf@evledraar.gmail.com/
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-04-13 20:01:35 +00:00
|
|
|
release_revisions(&rev_info);
|
2016-10-07 16:08:38 +00:00
|
|
|
return diff_result_code(&rev_info.diffopt, result);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* If the work tree has unstaged or uncommitted changes, dies with the
|
|
|
|
* appropriate message.
|
|
|
|
*/
|
2018-11-10 05:48:49 +00:00
|
|
|
int require_clean_work_tree(struct repository *r,
|
|
|
|
const char *action,
|
|
|
|
const char *hint,
|
|
|
|
int ignore_submodules,
|
|
|
|
int gently)
|
2016-10-07 16:08:38 +00:00
|
|
|
{
|
2017-10-05 20:32:04 +00:00
|
|
|
struct lock_file lock_file = LOCK_INIT;
|
2016-12-07 19:11:26 +00:00
|
|
|
int err = 0, fd;
|
2016-10-07 16:08:38 +00:00
|
|
|
|
2019-01-12 02:13:24 +00:00
|
|
|
fd = repo_hold_locked_index(r, &lock_file, 0);
|
2018-11-10 05:48:49 +00:00
|
|
|
refresh_index(r->index, REFRESH_QUIET, NULL, NULL, NULL);
|
2016-12-07 19:11:26 +00:00
|
|
|
if (0 <= fd)
|
2019-01-12 02:13:27 +00:00
|
|
|
repo_update_index_if_able(r, &lock_file);
|
2017-10-05 20:32:04 +00:00
|
|
|
rollback_lock_file(&lock_file);
|
2016-10-07 16:08:38 +00:00
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
if (has_unstaged_changes(r, ignore_submodules)) {
|
2016-10-07 16:08:38 +00:00
|
|
|
/* TRANSLATORS: the action is e.g. "pull with rebase" */
|
2016-10-07 16:09:04 +00:00
|
|
|
error(_("cannot %s: You have unstaged changes."), _(action));
|
2016-10-07 16:08:38 +00:00
|
|
|
err = 1;
|
|
|
|
}
|
|
|
|
|
2018-11-10 05:48:49 +00:00
|
|
|
if (has_uncommitted_changes(r, ignore_submodules)) {
|
2016-10-07 16:08:38 +00:00
|
|
|
if (err)
|
2016-10-07 16:09:04 +00:00
|
|
|
error(_("additionally, your index contains uncommitted changes."));
|
2016-10-07 16:08:38 +00:00
|
|
|
else
|
2016-10-07 16:09:04 +00:00
|
|
|
error(_("cannot %s: Your index contains uncommitted changes."),
|
2016-10-07 16:08:38 +00:00
|
|
|
_(action));
|
|
|
|
err = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
if (hint)
|
|
|
|
error("%s", hint);
|
|
|
|
if (!gently)
|
|
|
|
exit(128);
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|