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"
|
2013-09-06 17:43:05 +00:00
|
|
|
#include "argv-array.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"
|
2006-09-08 08:05:34 +00:00
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2006-09-08 08:05:34 +00:00
|
|
|
void wt_status_prepare(struct wt_status *s)
|
|
|
|
{
|
2017-02-21 23:47:29 +00:00
|
|
|
struct object_id oid;
|
2006-09-08 08:05:34 +00:00
|
|
|
|
2007-02-10 00:22:42 +00:00
|
|
|
memset(s, 0, sizeof(*s));
|
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-02-21 23:47:29 +00:00
|
|
|
s->branch = resolve_refdup("HEAD", 0, oid.hash, 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;
|
2013-09-06 17:43:07 +00:00
|
|
|
s->display_comment_prefix = 0;
|
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
|
|
|
;
|
|
|
|
else if (!s->is_initial)
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _(" (use \"git reset %s <file>...\" to unstage)"), s->reference);
|
2009-08-05 07:04:51 +00:00
|
|
|
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)"));
|
|
|
|
}
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf_ln(s, c, "%s", "");
|
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"??? */
|
|
|
|
else if (!s->is_initial)
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _(" (use \"git reset %s <file>...\" to unstage)"), s->reference);
|
2009-12-12 07:53:41 +00:00
|
|
|
else
|
2011-02-22 23:42:13 +00:00
|
|
|
status_printf_ln(s, c, _(" (use \"git rm --cached <file>...\" to unstage)"));
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf_ln(s, c, "%s", "");
|
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)"));
|
|
|
|
status_printf_ln(s, c, _(" (use \"git checkout -- <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)"));
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf_ln(s, c, "%s", "");
|
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);
|
2014-05-04 06:12:55 +00:00
|
|
|
status_printf_ln(s, c, "%s", "");
|
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
|
|
|
}
|
|
|
|
|
2008-03-07 02:30:58 +00:00
|
|
|
#define quote_path quote_path_relative
|
2006-11-08 21:20:46 +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:
|
2016-07-26 16:05:50 +00:00
|
|
|
die("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);
|
|
|
|
}
|
|
|
|
|
|
|
|
one = quote_path(it->string, s->prefix, &onebuf);
|
|
|
|
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;
|
|
|
|
if (d->head_path)
|
|
|
|
one_name = d->head_path;
|
|
|
|
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:
|
2016-08-05 22:00:26 +00:00
|
|
|
die("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
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:45 +00:00
|
|
|
one = quote_path(one_name, s->prefix, &onebuf);
|
|
|
|
two = quote_path(two_name, s->prefix, &twobuf);
|
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)
|
2016-07-26 16:05:50 +00:00
|
|
|
die("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);
|
|
|
|
if (status == DIFF_STATUS_COPIED || status == DIFF_STATUS_RENAMED)
|
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
|
|
|
}
|
|
|
|
|
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
|
|
|
static char short_submodule_status(struct wt_status_change_data *d) {
|
|
|
|
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];
|
2010-06-25 23:41:35 +00:00
|
|
|
it = string_list_insert(&s->change, p->one->path);
|
2009-08-05 06:49:33 +00:00
|
|
|
d = it->util;
|
|
|
|
if (!d) {
|
|
|
|
d = xcalloc(1, sizeof(*d));
|
|
|
|
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;
|
2016-06-24 23:09:23 +00:00
|
|
|
d->new_submodule_commits = !!oidcmp(&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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
case DIFF_STATUS_UNKNOWN:
|
|
|
|
die("BUG: worktree status unknown???");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-09-08 08:05:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-05 07:04:51 +00:00
|
|
|
static int unmerged_mask(const char *path)
|
|
|
|
{
|
|
|
|
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
|
|
|
|
|
|
|
pos = cache_name_pos(path, strlen(path));
|
|
|
|
if (0 <= pos)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
mask = 0;
|
|
|
|
pos = -pos-1;
|
|
|
|
while (pos < active_nr) {
|
|
|
|
ce = active_cache[pos++];
|
|
|
|
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) {
|
|
|
|
d = xcalloc(1, sizeof(*d));
|
|
|
|
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);
|
|
|
|
break;
|
|
|
|
case DIFF_STATUS_DELETED:
|
|
|
|
d->mode_head = p->one->mode;
|
|
|
|
oidcpy(&d->oid_head, &p->one->oid);
|
|
|
|
/* 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:
|
|
|
|
d->head_path = xstrdup(p->one->path);
|
2016-08-11 14:45:57 +00:00
|
|
|
d->score = p->score * 100 / MAX_SCORE;
|
|
|
|
/* 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);
|
2009-08-05 06:49:33 +00:00
|
|
|
break;
|
2009-08-05 07:04:51 +00:00
|
|
|
case DIFF_STATUS_UNMERGED:
|
|
|
|
d->stagemask = unmerged_mask(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;
|
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
|
|
|
|
|
|
|
init_revisions(&rev, NULL);
|
|
|
|
setup_revisions(0, NULL, &rev, NULL);
|
|
|
|
rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
|
2010-03-08 12:53:19 +00:00
|
|
|
DIFF_OPT_SET(&rev.diffopt, DIRTY_SUBMODULES);
|
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)
|
|
|
|
DIFF_OPT_SET(&rev.diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
|
2010-08-05 22:39:25 +00:00
|
|
|
if (s->ignore_submodule_arg) {
|
|
|
|
DIFF_OPT_SET(&rev.diffopt, OVERRIDE_SUBMODULE_CONFIG);
|
2010-06-25 14:56:47 +00:00
|
|
|
handle_ignore_submodules_arg(&rev.diffopt, s->ignore_submodule_arg);
|
2011-10-24 04:24:51 +00:00
|
|
|
}
|
2009-08-05 06:49:33 +00:00
|
|
|
rev.diffopt.format_callback = wt_status_collect_changed_cb;
|
|
|
|
rev.diffopt.format_callback_data = s;
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
2006-09-08 08:05:34 +00:00
|
|
|
init_revisions(&rev, NULL);
|
2010-03-09 06:58:09 +00:00
|
|
|
memset(&opt, 0, sizeof(opt));
|
|
|
|
opt.def = s->is_initial ? EMPTY_TREE_SHA1_HEX : s->reference;
|
|
|
|
setup_revisions(0, NULL, &rev, &opt);
|
|
|
|
|
2014-04-05 16:59:03 +00:00
|
|
|
DIFF_OPT_SET(&rev.diffopt, OVERRIDE_SUBMODULE_CONFIG);
|
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
|
|
|
|
* shown any submodules she manually added (and which are
|
|
|
|
* 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;
|
|
|
|
rev.diffopt.detect_rename = 1;
|
2008-04-30 17:24:43 +00:00
|
|
|
rev.diffopt.rename_limit = 200;
|
2007-12-03 06:58:37 +00:00
|
|
|
rev.diffopt.break_opt = 0;
|
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);
|
|
|
|
}
|
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
static void wt_status_collect_changes_initial(struct wt_status *s)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
struct string_list_item *it;
|
|
|
|
struct wt_status_change_data *d;
|
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 = active_cache[i];
|
2009-08-05 06:49:33 +00:00
|
|
|
|
2014-01-24 13:40:28 +00:00
|
|
|
if (!ce_path_match(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;
|
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) {
|
|
|
|
d = xcalloc(1, sizeof(*d));
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
} 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);
|
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;
|
|
|
|
struct dir_struct dir;
|
2014-07-12 00:07:36 +00:00
|
|
|
uint64_t t_begin = getnanotime();
|
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
|
|
|
memset(&dir, 0, sizeof(dir));
|
|
|
|
if (s->show_untracked_files != SHOW_ALL_UNTRACKED_FILES)
|
|
|
|
dir.flags |=
|
|
|
|
DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;
|
2013-04-15 19:15:03 +00:00
|
|
|
if (s->show_ignored_files)
|
|
|
|
dir.flags |= DIR_SHOW_IGNORED_TOO;
|
2015-03-08 10:12:41 +00:00
|
|
|
else
|
|
|
|
dir.untracked = the_index.untracked;
|
2009-08-10 07:36:33 +00:00
|
|
|
setup_standard_excludes(&dir);
|
|
|
|
|
2017-05-05 19:53:34 +00:00
|
|
|
fill_directory(&dir, &the_index, &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];
|
2010-09-27 02:49:13 +00:00
|
|
|
if (cache_name_is_other(ent->name, ent->len) &&
|
2014-01-24 13:40:29 +00:00
|
|
|
dir_path_match(ent, &s->pathspec, 0, NULL))
|
2010-09-27 02:49:13 +00:00
|
|
|
string_list_insert(&s->untracked, ent->name);
|
2010-04-10 06:58:27 +00:00
|
|
|
free(ent);
|
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];
|
|
|
|
if (cache_name_is_other(ent->name, ent->len) &&
|
2014-01-24 13:40:29 +00:00
|
|
|
dir_path_match(ent, &s->pathspec, 0, NULL))
|
2013-04-15 19:15:03 +00:00
|
|
|
string_list_insert(&s->ignored, ent->name);
|
|
|
|
free(ent);
|
2010-04-10 07:11:53 +00:00
|
|
|
}
|
|
|
|
|
2010-04-10 06:58:27 +00:00
|
|
|
free(dir.entries);
|
2013-04-15 19:15:03 +00:00
|
|
|
free(dir.ignored);
|
|
|
|
clear_directory(&dir);
|
2013-03-13 12:59:16 +00:00
|
|
|
|
2014-07-12 00:07:36 +00:00
|
|
|
if (advice_status_u_option)
|
|
|
|
s->untracked_in_ms = (getnanotime() - t_begin) / 1000000;
|
2009-08-10 07:36:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void wt_status_collect(struct wt_status *s)
|
2009-08-05 06:49:33 +00:00
|
|
|
{
|
|
|
|
wt_status_collect_changes_worktree(s);
|
|
|
|
|
|
|
|
if (s->is_initial)
|
|
|
|
wt_status_collect_changes_initial(s);
|
|
|
|
else
|
|
|
|
wt_status_collect_changes_index(s);
|
2009-08-10 07:36:33 +00:00
|
|
|
wt_status_collect_untracked(s);
|
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
|
|
|
s->commitable = 1;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wt_longstatus_print_stash_summary(struct wt_status *s)
|
|
|
|
{
|
|
|
|
int stash_count = 0;
|
|
|
|
|
|
|
|
for_each_reflog_ent("refs/stash", stash_count_refs, &stash_count);
|
|
|
|
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
|
|
|
|
2014-10-19 11:14:20 +00:00
|
|
|
argv_array_pushf(&sm_summary.env_array, "GIT_INDEX_FILE=%s",
|
|
|
|
s->index_file);
|
2008-04-12 15:05:32 +00:00
|
|
|
|
2014-11-09 13:49:54 +00:00
|
|
|
argv_array_push(&sm_summary.args, "submodule");
|
|
|
|
argv_array_push(&sm_summary.args, "summary");
|
|
|
|
argv_array_push(&sm_summary.args, uncommitted ? "--files" : "--cached");
|
|
|
|
argv_array_push(&sm_summary.args, "--for-status");
|
|
|
|
argv_array_push(&sm_summary.args, "--summary-limit");
|
|
|
|
argv_array_pushf(&sm_summary.args, "%d", s->submodule_summary);
|
2013-09-06 17:43:05 +00:00
|
|
|
if (!uncommitted)
|
2014-11-09 13:49:54 +00:00
|
|
|
argv_array_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]);
|
2013-06-25 15:53:45 +00:00
|
|
|
path = quote_path(it->string, s->prefix, &buf);
|
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
|
|
|
}
|
|
|
|
|
2014-02-17 12:15:31 +00:00
|
|
|
void wt_status_add_cut_line(FILE *fp)
|
|
|
|
{
|
|
|
|
const char *explanation = _("Do not touch the line above.\nEverything below will be removed.");
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
fprintf(fp, "%c %s", comment_line_char, cut_line);
|
|
|
|
strbuf_add_commented_lines(&buf, explanation, strlen(explanation));
|
|
|
|
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
|
|
|
|
2006-09-08 08:05:34 +00:00
|
|
|
init_revisions(&rev, NULL);
|
2008-12-08 02:54:17 +00:00
|
|
|
DIFF_OPT_SET(&rev.diffopt, ALLOW_TEXTCONV);
|
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));
|
|
|
|
opt.def = s->is_initial ? EMPTY_TREE_SHA1_HEX : s->reference;
|
|
|
|
setup_revisions(0, NULL, &rev, &opt);
|
|
|
|
|
2006-09-08 08:05:34 +00:00
|
|
|
rev.diffopt.output_format |= DIFF_FORMAT_PATCH;
|
|
|
|
rev.diffopt.detect_rename = 1;
|
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
|
|
|
}
|
2015-03-06 09:43:35 +00:00
|
|
|
if (s->verbose > 1 && s->commitable) {
|
|
|
|
/* 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);
|
|
|
|
}
|
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;
|
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);
|
2008-07-02 07:52:16 +00:00
|
|
|
if (!format_tracking_info(branch, &sb))
|
|
|
|
return;
|
|
|
|
|
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 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void show_merge_in_progress(struct wt_status *s,
|
|
|
|
struct wt_status_state *state,
|
|
|
|
const char *color)
|
|
|
|
{
|
|
|
|
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 {
|
2016-02-16 02:38:25 +00:00
|
|
|
s-> commitable = 1;
|
2012-06-05 20:21:24 +00:00
|
|
|
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,
|
|
|
|
struct wt_status_state *state,
|
|
|
|
const char *color)
|
|
|
|
{
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are in the middle of an am session."));
|
|
|
|
if (state->am_empty_patch)
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("The current patch is empty."));
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints) {
|
2012-06-05 20:21:24 +00:00
|
|
|
if (!state->am_empty_patch)
|
|
|
|
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)"));
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static void abbrev_sha1_in_line(struct strbuf *line)
|
|
|
|
{
|
|
|
|
struct strbuf **split;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (starts_with(line->buf, "exec ") ||
|
|
|
|
starts_with(line->buf, "x "))
|
|
|
|
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]);
|
2017-02-21 23:47:37 +00:00
|
|
|
strbuf_add_unique_abbrev(split[1], oid.hash,
|
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;
|
|
|
|
abbrev_sha1_in_line(&line);
|
|
|
|
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,
|
|
|
|
struct wt_status_state *state,
|
|
|
|
const char *color)
|
|
|
|
{
|
|
|
|
if (state->rebase_interactive_in_progress) {
|
|
|
|
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,
|
|
|
|
Q_("Last command done (%d command done):",
|
|
|
|
"Last commands done (%d commands done):",
|
|
|
|
have_done.nr),
|
|
|
|
have_done.nr);
|
|
|
|
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,
|
|
|
|
Q_("Next command to do (%d remaining command):",
|
|
|
|
"Next commands to do (%d remaining commands):",
|
|
|
|
yet_to_do.nr),
|
|
|
|
yet_to_do.nr);
|
|
|
|
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,
|
|
|
|
struct wt_status_state *state,
|
|
|
|
const char *color)
|
|
|
|
{
|
|
|
|
if (state->branch)
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently rebasing branch '%s' on '%s'."),
|
|
|
|
state->branch,
|
|
|
|
state->onto);
|
|
|
|
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,
|
|
|
|
struct wt_status_state *state,
|
|
|
|
const char *color)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
2015-07-06 20:56:03 +00:00
|
|
|
show_rebase_information(s, state, color);
|
2012-06-05 20:21:24 +00:00
|
|
|
if (has_unmerged(s)) {
|
2015-06-30 13:01:12 +00:00
|
|
|
print_rebase_state(s, state, 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)"));
|
|
|
|
}
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
} else if (state->rebase_in_progress || !stat(git_path_merge_msg(), &st)) {
|
2015-06-30 13:01:12 +00:00
|
|
|
print_rebase_state(s, state, 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)) {
|
2013-02-03 05:53:27 +00:00
|
|
|
if (state->branch)
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently splitting a commit while rebasing branch '%s' on '%s'."),
|
|
|
|
state->branch,
|
|
|
|
state->onto);
|
|
|
|
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 {
|
2013-02-03 05:53:27 +00:00
|
|
|
if (state->branch)
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_("You are currently editing a commit while rebasing branch '%s' on '%s'."),
|
|
|
|
state->branch,
|
|
|
|
state->onto);
|
|
|
|
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,
|
|
|
|
struct wt_status_state *state,
|
|
|
|
const char *color)
|
|
|
|
{
|
2013-10-11 15:58:37 +00:00
|
|
|
status_printf_ln(s, color, _("You are currently cherry-picking commit %s."),
|
|
|
|
find_unique_abbrev(state->cherry_pick_head_sha1, 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\")"));
|
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\")"));
|
|
|
|
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,
|
|
|
|
struct wt_status_state *state,
|
|
|
|
const char *color)
|
|
|
|
{
|
2013-04-02 14:20:22 +00:00
|
|
|
status_printf_ln(s, color, _("You are currently reverting commit %s."),
|
|
|
|
find_unique_abbrev(state->revert_head_sha1, 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\")"));
|
|
|
|
else
|
|
|
|
status_printf_ln(s, color,
|
|
|
|
_(" (all conflicts fixed: run \"git revert --continue\")"));
|
|
|
|
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,
|
|
|
|
struct wt_status_state *state,
|
|
|
|
const char *color)
|
|
|
|
{
|
2013-02-03 05:53:27 +00:00
|
|
|
if (state->branch)
|
|
|
|
status_printf_ln(s, color,
|
2013-03-23 03:52:44 +00:00
|
|
|
_("You are currently bisecting, started from branch '%s'."),
|
2013-02-03 05:53:27 +00:00
|
|
|
state->branch);
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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);
|
2017-02-21 23:47:37 +00:00
|
|
|
strbuf_add_unique_abbrev(&sb, oid.hash, 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);
|
2017-02-21 23:47:32 +00:00
|
|
|
strbuf_add_unique_abbrev(&cb->buf, noid->hash, DEFAULT_ABBREV);
|
2015-09-27 15:13:42 +00:00
|
|
|
}
|
2013-03-13 11:42:52 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wt_status_get_detached_from(struct wt_status_state *state)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-02-21 23:47:37 +00:00
|
|
|
if (dwim_ref(cb.buf.buf, cb.buf.len, oid.hash, &ref) == 1 &&
|
2013-03-13 11:42:52 +00:00
|
|
|
/* sha1 is a commit? match without further lookup */
|
2017-02-21 23:47:37 +00:00
|
|
|
(!oidcmp(&cb.noid, &oid) ||
|
2013-03-13 11:42:52 +00:00
|
|
|
/* perhaps sha1 is a tag, try to dereference to a commit */
|
Convert lookup_commit* to struct object_id
Convert lookup_commit, lookup_commit_or_die,
lookup_commit_reference, and lookup_commit_reference_gently to take
struct object_id arguments.
Introduce a temporary in parse_object buffer in order to convert this
function. This is required since in order to convert parse_object and
parse_object_buffer, lookup_commit_reference_gently and
lookup_commit_or_die would need to be converted. Not introducing a
temporary would therefore require that lookup_commit_or_die take a
struct object_id *, but lookup_commit would take unsigned char *,
leaving a confusing and hard-to-use interface.
parse_object_buffer will lose this temporary in a later patch.
This commit was created with manual changes to commit.c, commit.h, and
object.c, plus the following semantic patch:
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1.hash, E2)
+ lookup_commit_reference_gently(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1->hash, E2)
+ lookup_commit_reference_gently(E1, E2)
@@
expression E1;
@@
- lookup_commit_reference(E1.hash)
+ lookup_commit_reference(&E1)
@@
expression E1;
@@
- lookup_commit_reference(E1->hash)
+ lookup_commit_reference(E1)
@@
expression E1;
@@
- lookup_commit(E1.hash)
+ lookup_commit(&E1)
@@
expression E1;
@@
- lookup_commit(E1->hash)
+ lookup_commit(E1)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1.hash, E2)
+ lookup_commit_or_die(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1->hash, E2)
+ lookup_commit_or_die(E1, E2)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:10 +00:00
|
|
|
((commit = lookup_commit_reference_gently(&oid, 1)) != NULL &&
|
2017-02-21 23:47:37 +00:00
|
|
|
!oidcmp(&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 =
|
2017-02-21 23:47:37 +00:00
|
|
|
xstrdup(find_unique_abbrev(cb.noid.hash, DEFAULT_ABBREV));
|
|
|
|
hashcpy(state->detached_sha1, cb.noid.hash);
|
|
|
|
state->detached_at = !get_oid("HEAD", &oid) &&
|
|
|
|
!hashcmp(oid.hash, state->detached_sha1);
|
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;
|
|
|
|
}
|
|
|
|
|
2016-04-22 13:01:30 +00:00
|
|
|
void wt_status_get_state(struct wt_status_state *state,
|
|
|
|
int get_detached_from)
|
|
|
|
{
|
|
|
|
struct stat st;
|
2017-02-21 23:47:37 +00:00
|
|
|
struct object_id oid;
|
2016-04-22 13:01:30 +00:00
|
|
|
|
|
|
|
if (!stat(git_path_merge_head(), &st)) {
|
|
|
|
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 */
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
} else if (!stat(git_path_cherry_pick_head(), &st) &&
|
2017-02-21 23:47:37 +00:00
|
|
|
!get_oid("CHERRY_PICK_HEAD", &oid)) {
|
2013-03-13 11:42:50 +00:00
|
|
|
state->cherry_pick_in_progress = 1;
|
2017-02-21 23:47:37 +00:00
|
|
|
hashcpy(state->cherry_pick_head_sha1, oid.hash);
|
2012-06-05 20:21:24 +00:00
|
|
|
}
|
2016-04-22 13:01:34 +00:00
|
|
|
wt_status_check_bisect(NULL, state);
|
memoize common git-path "constant" files
One of the most common uses of git_path() is to pass a
constant, like git_path("MERGE_MSG"). This has two
drawbacks:
1. The return value is a static buffer, and the lifetime
is dependent on other calls to git_path, etc.
2. There's no compile-time checking of the pathname. This
is OK for a one-off (after all, we have to spell it
correctly at least once), but many of these constant
strings appear throughout the code.
This patch introduces a series of functions to "memoize"
these strings, which are essentially globals for the
lifetime of the program. We compute the value once, take
ownership of the buffer, and return the cached value for
subsequent calls. cache.h provides a helper macro for
defining these functions as one-liners, and defines a few
common ones for global use.
Using a macro is a little bit gross, but it does nicely
document the purpose of the functions. If we need to touch
them all later (e.g., because we learned how to change the
git_dir variable at runtime, and need to invalidate all of
the stored values), it will be much easier to have the
complete list.
Note that the shared-global functions have separate, manual
declarations. We could do something clever with the macros
(e.g., expand it to a declaration in some places, and a
declaration _and_ a definition in path.c). But there aren't
that many, and it's probably better to stay away from
too-magical macros.
Likewise, if we abandon the C preprocessor in favor of
generating these with a script, we could get much fancier.
E.g., normalizing "FOO/BAR-BAZ" into "git_path_foo_bar_baz".
But the small amount of saved typing is probably not worth
the resulting confusion to readers who want to grep for the
function's definition.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-08-10 09:38:57 +00:00
|
|
|
if (!stat(git_path_revert_head(), &st) &&
|
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;
|
2017-02-21 23:47:37 +00:00
|
|
|
hashcpy(state->revert_head_sha1, oid.hash);
|
2013-04-02 14:20:21 +00:00
|
|
|
}
|
2012-06-05 20:21:24 +00:00
|
|
|
|
2013-03-13 11:42:52 +00:00
|
|
|
if (get_detached_from)
|
|
|
|
wt_status_get_detached_from(state);
|
2013-03-13 11:42:50 +00:00
|
|
|
}
|
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
static void wt_longstatus_print_state(struct wt_status *s,
|
|
|
|
struct wt_status_state *state)
|
2013-03-13 11:42:50 +00:00
|
|
|
{
|
|
|
|
const char *state_color = color(WT_STATUS_HEADER, s);
|
2013-03-13 11:42:51 +00:00
|
|
|
if (state->merge_in_progress)
|
|
|
|
show_merge_in_progress(s, state, state_color);
|
|
|
|
else if (state->am_in_progress)
|
|
|
|
show_am_in_progress(s, state, state_color);
|
|
|
|
else if (state->rebase_in_progress || state->rebase_interactive_in_progress)
|
|
|
|
show_rebase_in_progress(s, state, state_color);
|
|
|
|
else if (state->cherry_pick_in_progress)
|
|
|
|
show_cherry_pick_in_progress(s, state, state_color);
|
2013-04-02 14:20:21 +00:00
|
|
|
else if (state->revert_in_progress)
|
|
|
|
show_revert_in_progress(s, state, state_color);
|
2013-03-13 11:42:51 +00:00
|
|
|
if (state->bisect_in_progress)
|
|
|
|
show_bisect_in_progress(s, state, 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);
|
2013-03-13 11:42:51 +00:00
|
|
|
struct wt_status_state state;
|
|
|
|
|
|
|
|
memset(&state, 0, sizeof(state));
|
2013-03-13 11:42:52 +00:00
|
|
|
wt_status_get_state(&state,
|
|
|
|
s->branch && !strcmp(s->branch, "HEAD"));
|
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);
|
status: do not depend on rebase reflog messages
b397ea4 (status: show more info than "currently not on any branch",
2013-03-13) attempted to make the output of 'git status' richer in
the case of a detached HEAD. Before this patch, with a detached
HEAD, we saw:
$ git status
# Not currently on any branch.
But after the patch, we see:
$ git checkout v1.8.2
$ git status
# HEAD detached at v1.8.2.
It works by digging the reflog for the most recent message of the
form "checkout: moving from xxxx to yyyy". It then asserts that
HEAD and "yyyy" are the same, and displays this message. When they
aren't equal, it displays:
$ git status
# HEAD detached from fe11db.
so that the user can see where the HEAD was first detached.
In case of a rebase [-i] operation in progress, this message depends
on the implementation of rebase writing "checkout: " messages to the
reflog, but that is an implementation detail of "rebase". To remove
this dependency so that rebase can be updated to write better reflog
messages, replace this "HEAD detached from" message with:
# rebase in progress; onto $ONTO
Changes to the commit object name in the expected output for some of
the tests shows that what the test expected "status" to show during
"rebase -i" was not consistent with the output during a vanilla
"rebase", which showed on top of what commit the series is being
replayed. Now we consistently expect something meaningful to the
end user.
Signed-off-by: Ramkumar Ramachandra <artagnon@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-06-16 08:45:15 +00:00
|
|
|
if (state.rebase_in_progress || state.rebase_interactive_in_progress) {
|
2015-06-30 13:01:13 +00:00
|
|
|
if (state.rebase_interactive_in_progress)
|
|
|
|
on_what = _("interactive rebase in progress; onto ");
|
|
|
|
else
|
|
|
|
on_what = _("rebase in progress; onto ");
|
status: do not depend on rebase reflog messages
b397ea4 (status: show more info than "currently not on any branch",
2013-03-13) attempted to make the output of 'git status' richer in
the case of a detached HEAD. Before this patch, with a detached
HEAD, we saw:
$ git status
# Not currently on any branch.
But after the patch, we see:
$ git checkout v1.8.2
$ git status
# HEAD detached at v1.8.2.
It works by digging the reflog for the most recent message of the
form "checkout: moving from xxxx to yyyy". It then asserts that
HEAD and "yyyy" are the same, and displays this message. When they
aren't equal, it displays:
$ git status
# HEAD detached from fe11db.
so that the user can see where the HEAD was first detached.
In case of a rebase [-i] operation in progress, this message depends
on the implementation of rebase writing "checkout: " messages to the
reflog, but that is an implementation detail of "rebase". To remove
this dependency so that rebase can be updated to write better reflog
messages, replace this "HEAD detached from" message with:
# rebase in progress; onto $ONTO
Changes to the commit object name in the expected output for some of
the tests shows that what the test expected "status" to show during
"rebase -i" was not consistent with the output during a vanilla
"rebase", which showed on top of what commit the series is being
replayed. Now we consistently expect something meaningful to the
end user.
Signed-off-by: Ramkumar Ramachandra <artagnon@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-06-16 08:45:15 +00:00
|
|
|
branch_name = state.onto;
|
|
|
|
} else if (state.detached_from) {
|
2013-03-13 11:42:52 +00:00
|
|
|
branch_name = state.detached_from;
|
2015-03-06 15:04:06 +00:00
|
|
|
if (state.detached_at)
|
2013-03-13 11:42:52 +00:00
|
|
|
on_what = _("HEAD detached at ");
|
|
|
|
else
|
|
|
|
on_what = _("HEAD detached from ");
|
|
|
|
} 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
|
|
|
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_state(s, &state);
|
2013-03-13 11:42:51 +00:00
|
|
|
free(state.branch);
|
|
|
|
free(state.onto);
|
2013-03-13 11:42:52 +00:00
|
|
|
free(state.detached_from);
|
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");
|
2010-04-10 07:33:17 +00:00
|
|
|
if (s->show_ignored_files)
|
2016-08-05 22:00:26 +00:00
|
|
|
wt_longstatus_print_other(s, &s->ignored, _("Ignored files"), "add -f");
|
2013-03-13 12:59:16 +00:00
|
|
|
if (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
|
|
|
}
|
2010-04-10 07:33:17 +00:00
|
|
|
} else if (s->commitable)
|
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);
|
2007-01-02 19:26:22 +00:00
|
|
|
if (!s->commitable) {
|
|
|
|
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)
|
2012-09-06 15:16:50 +00:00
|
|
|
printf(_("no changes added to commit "
|
|
|
|
"(use \"git add\" and/or \"git commit -a\")\n"));
|
|
|
|
else
|
|
|
|
printf(_("no changes added to commit\n"));
|
|
|
|
} else if (s->untracked.nr) {
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2012-09-06 15:16:50 +00:00
|
|
|
printf(_("nothing added to commit but untracked files "
|
|
|
|
"present (use \"git add\" to track)\n"));
|
|
|
|
else
|
|
|
|
printf(_("nothing added to commit but untracked files present\n"));
|
|
|
|
} else if (s->is_initial) {
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2012-09-06 15:16:50 +00:00
|
|
|
printf(_("nothing to commit (create/copy files "
|
|
|
|
"and use \"git add\" to track)\n"));
|
|
|
|
else
|
|
|
|
printf(_("nothing to commit\n"));
|
|
|
|
} else if (!s->show_untracked_files) {
|
2013-09-12 10:50:05 +00:00
|
|
|
if (s->hints)
|
2012-09-06 15:16:50 +00:00
|
|
|
printf(_("nothing to commit (use -u to show untracked files)\n"));
|
|
|
|
else
|
|
|
|
printf(_("nothing to commit\n"));
|
|
|
|
} else
|
2016-06-09 18:19:30 +00:00
|
|
|
printf(_("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) {
|
2009-12-05 15:04:38 +00:00
|
|
|
fprintf(stdout, " %s%c", it->string, 0);
|
2009-12-05 15:04:37 +00:00
|
|
|
} else {
|
|
|
|
struct strbuf onebuf = STRBUF_INIT;
|
|
|
|
const char *one;
|
2013-06-25 15:53:45 +00:00
|
|
|
one = quote_path(it->string, s->prefix, &onebuf);
|
2009-12-05 15:04:38 +00:00
|
|
|
printf(" %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
|
|
|
|
putchar(' ');
|
|
|
|
if (d->worktree_status)
|
|
|
|
color_fprintf(s->fp, color(WT_STATUS_CHANGED, s), "%c", d->worktree_status);
|
|
|
|
else
|
|
|
|
putchar(' ');
|
|
|
|
putchar(' ');
|
2012-05-07 19:44:44 +00:00
|
|
|
if (s->null_termination) {
|
2009-12-05 15:04:37 +00:00
|
|
|
fprintf(stdout, "%s%c", it->string, 0);
|
|
|
|
if (d->head_path)
|
|
|
|
fprintf(stdout, "%s%c", d->head_path, 0);
|
|
|
|
} else {
|
|
|
|
struct strbuf onebuf = STRBUF_INIT;
|
|
|
|
const char *one;
|
|
|
|
if (d->head_path) {
|
2013-06-25 15:53:45 +00:00
|
|
|
one = quote_path(d->head_path, s->prefix, &onebuf);
|
2010-11-09 02:44:38 +00:00
|
|
|
if (*one != '"' && strchr(one, ' ') != NULL) {
|
|
|
|
putchar('"');
|
|
|
|
strbuf_addch(&onebuf, '"');
|
|
|
|
one = onebuf.buf;
|
|
|
|
}
|
2009-12-05 15:04:37 +00:00
|
|
|
printf("%s -> ", one);
|
|
|
|
strbuf_release(&onebuf);
|
|
|
|
}
|
2013-06-25 15:53:45 +00:00
|
|
|
one = quote_path(it->string, s->prefix, &onebuf);
|
2010-11-09 02:44:38 +00:00
|
|
|
if (*one != '"' && strchr(one, ' ') != NULL) {
|
|
|
|
putchar('"');
|
|
|
|
strbuf_addch(&onebuf, '"');
|
|
|
|
one = onebuf.buf;
|
|
|
|
}
|
2009-12-05 15:04:37 +00:00
|
|
|
printf("%s\n", one);
|
|
|
|
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) {
|
2010-04-10 07:33:17 +00:00
|
|
|
fprintf(stdout, "%s %s%c", sign, it->string, 0);
|
2009-12-05 15:04:37 +00:00
|
|
|
} else {
|
|
|
|
struct strbuf onebuf = STRBUF_INIT;
|
|
|
|
const char *one;
|
2013-06-25 15:53:45 +00:00
|
|
|
one = quote_path(it->string, s->prefix, &onebuf);
|
2010-05-02 05:05:14 +00:00
|
|
|
color_fprintf(s->fp, color(WT_STATUS_UNTRACKED, s), "%s", sign);
|
2009-12-05 15:04:38 +00:00
|
|
|
printf(" %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;
|
|
|
|
int num_ours, num_theirs;
|
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);
|
|
|
|
|
2015-05-22 00:49:11 +00:00
|
|
|
if (stat_tracking_info(branch, &num_ours, &num_theirs, &base) < 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
|
|
|
|
2015-10-31 17:36:01 +00:00
|
|
|
if (!upstream_is_gone && !num_ours && !num_theirs)
|
|
|
|
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")));
|
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>]]
|
|
|
|
*
|
|
|
|
* <commit> ::= the current commit hash or the the literal
|
|
|
|
* "(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.
|
|
|
|
*
|
|
|
|
* <ahead> ::= integer ahead value, when upstream set
|
|
|
|
* and the commit is present (not gone).
|
|
|
|
*
|
|
|
|
* <behind> ::= integer behind value, when upstream set
|
|
|
|
* and commit is present.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* The end-of-line is defined by the -z flag.
|
|
|
|
*
|
|
|
|
* <eol> ::= NUL when -z,
|
|
|
|
* LF when NOT -z.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void wt_porcelain_v2_print_tracking(struct wt_status *s)
|
|
|
|
{
|
|
|
|
struct branch *branch;
|
|
|
|
const char *base;
|
|
|
|
const char *branch_name;
|
|
|
|
struct wt_status_state state;
|
|
|
|
int ab_info, nr_ahead, nr_behind;
|
|
|
|
char eol = s->null_termination ? '\0' : '\n';
|
|
|
|
|
|
|
|
memset(&state, 0, sizeof(state));
|
|
|
|
wt_status_get_state(&state, s->branch && !strcmp(s->branch, "HEAD"));
|
|
|
|
|
|
|
|
fprintf(s->fp, "# branch.oid %s%c",
|
|
|
|
(s->is_initial ? "(initial)" : sha1_to_hex(s->sha1_commit)),
|
|
|
|
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);
|
|
|
|
|
|
|
|
if (state.rebase_in_progress || state.rebase_interactive_in_progress)
|
|
|
|
branch_name = state.onto;
|
|
|
|
else if (state.detached_from)
|
|
|
|
branch_name = state.detached_from;
|
|
|
|
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;
|
|
|
|
ab_info = (stat_tracking_info(branch, &nr_ahead, &nr_behind, &base) == 0);
|
|
|
|
if (base) {
|
|
|
|
base = shorten_unambiguous_ref(base, 0);
|
|
|
|
fprintf(s->fp, "# branch.upstream %s%c", base, eol);
|
|
|
|
free((char *)base);
|
|
|
|
|
|
|
|
if (ab_info)
|
|
|
|
fprintf(s->fp, "# branch.ab +%d -%d%c", nr_ahead, nr_behind, eol);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
free(state.branch);
|
|
|
|
free(state.onto);
|
|
|
|
free(state.detached_from);
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static void wt_porcelain_v2_fix_up_changed(
|
|
|
|
struct string_list_item *it,
|
|
|
|
struct wt_status *s)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
struct strbuf buf_index = STRBUF_INIT;
|
|
|
|
struct strbuf buf_head = STRBUF_INIT;
|
|
|
|
const char *path_index = NULL;
|
|
|
|
const char *path_head = NULL;
|
|
|
|
char key[3];
|
|
|
|
char submodule_token[5];
|
|
|
|
char sep_char, eol_char;
|
|
|
|
|
|
|
|
wt_porcelain_v2_fix_up_changed(it, s);
|
|
|
|
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';
|
|
|
|
path_index = it->string;
|
|
|
|
path_head = d->head_path;
|
|
|
|
} 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';
|
|
|
|
path_index = quote_path(it->string, s->prefix, &buf_index);
|
|
|
|
if (d->head_path)
|
|
|
|
path_head = quote_path(d->head_path, s->prefix, &buf_head);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (path_head)
|
|
|
|
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),
|
|
|
|
key[0], d->score,
|
|
|
|
path_index, sep_char, path_head, eol_char);
|
|
|
|
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),
|
|
|
|
path_index, eol_char);
|
|
|
|
|
|
|
|
strbuf_release(&buf_index);
|
|
|
|
strbuf_release(&buf_head);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
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:
|
|
|
|
die("BUG: unhandled unmerged status %x", d->stagemask);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
pos = cache_name_pos(it->string, strlen(it->string));
|
|
|
|
assert(pos < 0);
|
|
|
|
pos = -pos-1;
|
|
|
|
while (pos < active_nr) {
|
|
|
|
ce = active_cache[pos++];
|
|
|
|
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)
|
|
|
|
die("BUG: observed stagemask 0x%x != expected stagemask 0x%x", sum, d->stagemask);
|
|
|
|
|
|
|
|
if (s->null_termination)
|
|
|
|
path_index = it->string;
|
|
|
|
else
|
|
|
|
path_index = quote_path(it->string, s->prefix, &buf_index);
|
|
|
|
|
|
|
|
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 {
|
|
|
|
path = quote_path(it->string, s->prefix, &buf);
|
|
|
|
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);
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
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:
|
|
|
|
die("BUG: finalize_deferred_config() should have been called");
|
|
|
|
break;
|
|
|
|
case STATUS_FORMAT_NONE:
|
|
|
|
case STATUS_FORMAT_LONG:
|
|
|
|
wt_longstatus_print(s);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-10-07 16:08:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns 1 if there are unstaged changes, 0 otherwise.
|
|
|
|
*/
|
2016-10-07 16:09:00 +00:00
|
|
|
int has_unstaged_changes(int ignore_submodules)
|
2016-10-07 16:08:38 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev_info;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
init_revisions(&rev_info, NULL);
|
2016-10-07 16:09:00 +00:00
|
|
|
if (ignore_submodules)
|
|
|
|
DIFF_OPT_SET(&rev_info.diffopt, IGNORE_SUBMODULES);
|
2016-10-07 16:08:38 +00:00
|
|
|
DIFF_OPT_SET(&rev_info.diffopt, QUICK);
|
|
|
|
diff_setup_done(&rev_info.diffopt);
|
|
|
|
result = run_diff_files(&rev_info, 0);
|
|
|
|
return diff_result_code(&rev_info.diffopt, result);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns 1 if there are uncommitted changes, 0 otherwise.
|
|
|
|
*/
|
2016-10-07 16:09:00 +00:00
|
|
|
int has_uncommitted_changes(int ignore_submodules)
|
2016-10-07 16:08:38 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev_info;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (is_cache_unborn())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
init_revisions(&rev_info, NULL);
|
2016-10-07 16:09:00 +00:00
|
|
|
if (ignore_submodules)
|
|
|
|
DIFF_OPT_SET(&rev_info.diffopt, IGNORE_SUBMODULES);
|
2016-10-07 16:08:38 +00:00
|
|
|
DIFF_OPT_SET(&rev_info.diffopt, QUICK);
|
|
|
|
add_head_to_pending(&rev_info);
|
|
|
|
diff_setup_done(&rev_info.diffopt);
|
|
|
|
result = run_diff_index(&rev_info, 1);
|
|
|
|
return diff_result_code(&rev_info.diffopt, result);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* If the work tree has unstaged or uncommitted changes, dies with the
|
|
|
|
* appropriate message.
|
|
|
|
*/
|
2016-10-07 16:09:00 +00:00
|
|
|
int require_clean_work_tree(const char *action, const char *hint, int ignore_submodules, int gently)
|
2016-10-07 16:08:38 +00:00
|
|
|
{
|
|
|
|
struct lock_file *lock_file = xcalloc(1, sizeof(*lock_file));
|
2016-12-07 19:11:26 +00:00
|
|
|
int err = 0, fd;
|
2016-10-07 16:08:38 +00:00
|
|
|
|
2016-12-07 19:11:26 +00:00
|
|
|
fd = hold_locked_index(lock_file, 0);
|
2016-10-07 16:08:38 +00:00
|
|
|
refresh_cache(REFRESH_QUIET);
|
2016-12-07 19:11:26 +00:00
|
|
|
if (0 <= fd)
|
|
|
|
update_index_if_able(&the_index, lock_file);
|
2016-10-07 16:08:38 +00:00
|
|
|
rollback_lock_file(lock_file);
|
|
|
|
|
2016-10-07 16:09:00 +00:00
|
|
|
if (has_unstaged_changes(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;
|
|
|
|
}
|
|
|
|
|
2016-10-07 16:09:00 +00:00
|
|
|
if (has_uncommitted_changes(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;
|
|
|
|
}
|