2015-06-13 19:37:27 +00:00
|
|
|
#include "builtin.h"
|
|
|
|
#include "cache.h"
|
|
|
|
#include "parse-options.h"
|
|
|
|
#include "refs.h"
|
|
|
|
#include "wildmatch.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "remote.h"
|
|
|
|
#include "color.h"
|
|
|
|
#include "tag.h"
|
|
|
|
#include "quote.h"
|
|
|
|
#include "ref-filter.h"
|
2015-07-07 16:06:12 +00:00
|
|
|
#include "revision.h"
|
2015-09-11 15:03:07 +00:00
|
|
|
#include "utf8.h"
|
2015-09-10 15:48:25 +00:00
|
|
|
#include "git-compat-util.h"
|
|
|
|
#include "version.h"
|
2016-11-19 00:58:15 +00:00
|
|
|
#include "trailer.h"
|
2017-01-10 08:49:38 +00:00
|
|
|
#include "wt-status.h"
|
2017-03-09 13:29:49 +00:00
|
|
|
#include "commit-slab.h"
|
2015-06-13 19:37:27 +00:00
|
|
|
|
2017-01-10 08:49:50 +00:00
|
|
|
static struct ref_msg {
|
|
|
|
const char *gone;
|
|
|
|
const char *ahead;
|
|
|
|
const char *behind;
|
|
|
|
const char *ahead_behind;
|
|
|
|
} msgs = {
|
|
|
|
/* Untranslated plumbing messages: */
|
|
|
|
"gone",
|
|
|
|
"ahead %d",
|
|
|
|
"behind %d",
|
|
|
|
"ahead %d, behind %d"
|
|
|
|
};
|
|
|
|
|
|
|
|
void setup_ref_filter_porcelain_msg(void)
|
|
|
|
{
|
|
|
|
msgs.gone = _("gone");
|
|
|
|
msgs.ahead = _("ahead %d");
|
|
|
|
msgs.behind = _("behind %d");
|
|
|
|
msgs.ahead_behind = _("ahead %d, behind %d");
|
|
|
|
}
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
typedef enum { FIELD_STR, FIELD_ULONG, FIELD_TIME } cmp_type;
|
2017-01-10 08:49:36 +00:00
|
|
|
typedef enum { COMPARE_EQUAL, COMPARE_UNEQUAL, COMPARE_NONE } cmp_status;
|
2015-06-13 19:37:27 +00:00
|
|
|
|
2016-02-17 18:06:15 +00:00
|
|
|
struct align {
|
|
|
|
align_type position;
|
|
|
|
unsigned int width;
|
|
|
|
};
|
|
|
|
|
2017-01-10 08:49:34 +00:00
|
|
|
struct if_then_else {
|
2017-01-10 08:49:36 +00:00
|
|
|
cmp_status cmp_status;
|
|
|
|
const char *str;
|
2017-01-10 08:49:34 +00:00
|
|
|
unsigned int then_atom_seen : 1,
|
|
|
|
else_atom_seen : 1,
|
|
|
|
condition_satisfied : 1;
|
|
|
|
};
|
|
|
|
|
2017-01-10 08:49:43 +00:00
|
|
|
struct refname_atom {
|
2017-01-10 08:49:49 +00:00
|
|
|
enum { R_NORMAL, R_SHORT, R_LSTRIP, R_RSTRIP } option;
|
|
|
|
int lstrip, rstrip;
|
2017-01-10 08:49:43 +00:00
|
|
|
};
|
|
|
|
|
2016-02-17 18:06:10 +00:00
|
|
|
/*
|
|
|
|
* An atom is a valid field atom listed below, possibly prefixed with
|
|
|
|
* a "*" to denote deref_tag().
|
|
|
|
*
|
|
|
|
* We parse given format string and sort specifiers, and make a list
|
|
|
|
* of properties that we need to extract out of objects. ref_array_item
|
|
|
|
* structure will hold an array of values extracted that can be
|
|
|
|
* indexed with the "atom number", which is an index into this
|
|
|
|
* array.
|
|
|
|
*/
|
2016-02-17 18:06:11 +00:00
|
|
|
static struct used_atom {
|
|
|
|
const char *name;
|
|
|
|
cmp_type type;
|
2016-02-17 18:06:13 +00:00
|
|
|
union {
|
|
|
|
char color[COLOR_MAXLEN];
|
2016-02-17 18:06:15 +00:00
|
|
|
struct align align;
|
2017-01-10 08:49:41 +00:00
|
|
|
struct {
|
2017-01-10 08:49:45 +00:00
|
|
|
enum { RR_REF, RR_TRACK, RR_TRACKSHORT } option;
|
|
|
|
struct refname_atom refname;
|
2017-01-10 08:49:41 +00:00
|
|
|
unsigned int nobracket : 1;
|
|
|
|
} remote_ref;
|
2016-02-17 18:06:18 +00:00
|
|
|
struct {
|
2016-11-19 00:58:15 +00:00
|
|
|
enum { C_BARE, C_BODY, C_BODY_DEP, C_LINES, C_SIG, C_SUB, C_TRAILERS } option;
|
2016-02-17 18:06:18 +00:00
|
|
|
unsigned int nlines;
|
|
|
|
} contents;
|
2017-01-10 08:49:36 +00:00
|
|
|
struct {
|
|
|
|
cmp_status cmp_status;
|
|
|
|
const char *str;
|
|
|
|
} if_then_else;
|
2017-01-10 08:49:37 +00:00
|
|
|
struct {
|
|
|
|
enum { O_FULL, O_LENGTH, O_SHORT } option;
|
|
|
|
unsigned int length;
|
|
|
|
} objectname;
|
2017-01-10 08:49:43 +00:00
|
|
|
struct refname_atom refname;
|
2017-05-19 06:12:12 +00:00
|
|
|
char *head;
|
2016-02-17 18:06:13 +00:00
|
|
|
} u;
|
2016-02-17 18:06:11 +00:00
|
|
|
} *used_atom;
|
2016-02-17 18:06:10 +00:00
|
|
|
static int used_atom_cnt, need_tagged, need_symref;
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void color_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *color_value)
|
2016-02-17 18:06:13 +00:00
|
|
|
{
|
|
|
|
if (!color_value)
|
|
|
|
die(_("expected format: %%(color:<color>)"));
|
|
|
|
if (color_parse(color_value, atom->u.color) < 0)
|
|
|
|
die(_("unrecognized color: %%(color:%s)"), color_value);
|
|
|
|
}
|
|
|
|
|
2017-01-10 08:49:43 +00:00
|
|
|
static void refname_atom_parser_internal(struct refname_atom *atom,
|
|
|
|
const char *arg, const char *name)
|
2016-02-17 18:06:17 +00:00
|
|
|
{
|
|
|
|
if (!arg)
|
2017-01-10 08:49:43 +00:00
|
|
|
atom->option = R_NORMAL;
|
2016-02-17 18:06:17 +00:00
|
|
|
else if (!strcmp(arg, "short"))
|
2017-01-10 08:49:43 +00:00
|
|
|
atom->option = R_SHORT;
|
2017-02-07 19:50:34 +00:00
|
|
|
else if (skip_prefix(arg, "lstrip=", &arg) ||
|
|
|
|
skip_prefix(arg, "strip=", &arg)) {
|
2017-01-10 08:49:46 +00:00
|
|
|
atom->option = R_LSTRIP;
|
2017-01-10 08:49:48 +00:00
|
|
|
if (strtol_i(arg, 10, &atom->lstrip))
|
|
|
|
die(_("Integer value expected refname:lstrip=%s"), arg);
|
2017-01-10 08:49:49 +00:00
|
|
|
} else if (skip_prefix(arg, "rstrip=", &arg)) {
|
|
|
|
atom->option = R_RSTRIP;
|
|
|
|
if (strtol_i(arg, 10, &atom->rstrip))
|
|
|
|
die(_("Integer value expected refname:rstrip=%s"), arg);
|
2017-01-10 08:49:43 +00:00
|
|
|
} else
|
|
|
|
die(_("unrecognized %%(%s) argument: %s"), name, arg);
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void remote_ref_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2016-02-17 18:06:17 +00:00
|
|
|
{
|
2017-01-10 08:49:41 +00:00
|
|
|
struct string_list params = STRING_LIST_INIT_DUP;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!arg) {
|
2017-01-10 08:49:45 +00:00
|
|
|
atom->u.remote_ref.option = RR_REF;
|
|
|
|
refname_atom_parser_internal(&atom->u.remote_ref.refname,
|
|
|
|
arg, atom->name);
|
2017-01-10 08:49:41 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
atom->u.remote_ref.nobracket = 0;
|
|
|
|
string_list_split(¶ms, arg, ',', -1);
|
|
|
|
|
|
|
|
for (i = 0; i < params.nr; i++) {
|
|
|
|
const char *s = params.items[i].string;
|
|
|
|
|
2017-01-10 08:49:45 +00:00
|
|
|
if (!strcmp(s, "track"))
|
2017-01-10 08:49:41 +00:00
|
|
|
atom->u.remote_ref.option = RR_TRACK;
|
|
|
|
else if (!strcmp(s, "trackshort"))
|
|
|
|
atom->u.remote_ref.option = RR_TRACKSHORT;
|
|
|
|
else if (!strcmp(s, "nobracket"))
|
|
|
|
atom->u.remote_ref.nobracket = 1;
|
2017-01-10 08:49:45 +00:00
|
|
|
else {
|
|
|
|
atom->u.remote_ref.option = RR_REF;
|
|
|
|
refname_atom_parser_internal(&atom->u.remote_ref.refname,
|
|
|
|
arg, atom->name);
|
|
|
|
}
|
2017-01-10 08:49:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
string_list_clear(¶ms, 0);
|
2016-02-17 18:06:17 +00:00
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void body_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2016-02-17 18:06:18 +00:00
|
|
|
{
|
|
|
|
if (arg)
|
2016-02-27 06:42:04 +00:00
|
|
|
die(_("%%(body) does not take arguments"));
|
2016-02-17 18:06:18 +00:00
|
|
|
atom->u.contents.option = C_BODY_DEP;
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void subject_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2016-02-17 18:06:18 +00:00
|
|
|
{
|
|
|
|
if (arg)
|
2016-02-27 06:42:04 +00:00
|
|
|
die(_("%%(subject) does not take arguments"));
|
2016-02-17 18:06:18 +00:00
|
|
|
atom->u.contents.option = C_SUB;
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void trailers_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2016-11-19 00:58:15 +00:00
|
|
|
{
|
|
|
|
if (arg)
|
|
|
|
die(_("%%(trailers) does not take arguments"));
|
|
|
|
atom->u.contents.option = C_TRAILERS;
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void contents_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2016-02-17 18:06:18 +00:00
|
|
|
{
|
|
|
|
if (!arg)
|
|
|
|
atom->u.contents.option = C_BARE;
|
|
|
|
else if (!strcmp(arg, "body"))
|
|
|
|
atom->u.contents.option = C_BODY;
|
|
|
|
else if (!strcmp(arg, "signature"))
|
|
|
|
atom->u.contents.option = C_SIG;
|
|
|
|
else if (!strcmp(arg, "subject"))
|
|
|
|
atom->u.contents.option = C_SUB;
|
2016-11-19 00:58:15 +00:00
|
|
|
else if (!strcmp(arg, "trailers"))
|
|
|
|
atom->u.contents.option = C_TRAILERS;
|
2016-02-17 18:06:18 +00:00
|
|
|
else if (skip_prefix(arg, "lines=", &arg)) {
|
|
|
|
atom->u.contents.option = C_LINES;
|
|
|
|
if (strtoul_ui(arg, 10, &atom->u.contents.nlines))
|
|
|
|
die(_("positive value expected contents:lines=%s"), arg);
|
|
|
|
} else
|
|
|
|
die(_("unrecognized %%(contents) argument: %s"), arg);
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void objectname_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2016-02-17 18:06:19 +00:00
|
|
|
{
|
|
|
|
if (!arg)
|
2017-01-10 08:49:37 +00:00
|
|
|
atom->u.objectname.option = O_FULL;
|
2016-02-17 18:06:19 +00:00
|
|
|
else if (!strcmp(arg, "short"))
|
2017-01-10 08:49:37 +00:00
|
|
|
atom->u.objectname.option = O_SHORT;
|
|
|
|
else if (skip_prefix(arg, "short=", &arg)) {
|
|
|
|
atom->u.objectname.option = O_LENGTH;
|
|
|
|
if (strtoul_ui(arg, 10, &atom->u.objectname.length) ||
|
|
|
|
atom->u.objectname.length == 0)
|
|
|
|
die(_("positive value expected objectname:short=%s"), arg);
|
|
|
|
if (atom->u.objectname.length < MINIMUM_ABBREV)
|
|
|
|
atom->u.objectname.length = MINIMUM_ABBREV;
|
|
|
|
} else
|
2016-02-17 18:06:19 +00:00
|
|
|
die(_("unrecognized %%(objectname) argument: %s"), arg);
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void refname_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2017-01-10 08:49:44 +00:00
|
|
|
{
|
2017-07-10 19:03:03 +00:00
|
|
|
refname_atom_parser_internal(&atom->u.refname, arg, atom->name);
|
2017-01-10 08:49:44 +00:00
|
|
|
}
|
|
|
|
|
2016-02-17 18:06:14 +00:00
|
|
|
static align_type parse_align_position(const char *s)
|
|
|
|
{
|
|
|
|
if (!strcmp(s, "right"))
|
|
|
|
return ALIGN_RIGHT;
|
|
|
|
else if (!strcmp(s, "middle"))
|
|
|
|
return ALIGN_MIDDLE;
|
|
|
|
else if (!strcmp(s, "left"))
|
|
|
|
return ALIGN_LEFT;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void align_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2016-02-17 18:06:15 +00:00
|
|
|
{
|
|
|
|
struct align *align = &atom->u.align;
|
|
|
|
struct string_list params = STRING_LIST_INIT_DUP;
|
|
|
|
int i;
|
|
|
|
unsigned int width = ~0U;
|
|
|
|
|
|
|
|
if (!arg)
|
|
|
|
die(_("expected format: %%(align:<width>,<position>)"));
|
|
|
|
|
|
|
|
align->position = ALIGN_LEFT;
|
|
|
|
|
|
|
|
string_list_split(¶ms, arg, ',', -1);
|
|
|
|
for (i = 0; i < params.nr; i++) {
|
|
|
|
const char *s = params.items[i].string;
|
|
|
|
int position;
|
|
|
|
|
2016-02-17 18:06:16 +00:00
|
|
|
if (skip_prefix(s, "position=", &s)) {
|
|
|
|
position = parse_align_position(s);
|
|
|
|
if (position < 0)
|
|
|
|
die(_("unrecognized position:%s"), s);
|
|
|
|
align->position = position;
|
|
|
|
} else if (skip_prefix(s, "width=", &s)) {
|
|
|
|
if (strtoul_ui(s, 10, &width))
|
|
|
|
die(_("unrecognized width:%s"), s);
|
|
|
|
} else if (!strtoul_ui(s, 10, &width))
|
2016-02-17 18:06:15 +00:00
|
|
|
;
|
|
|
|
else if ((position = parse_align_position(s)) >= 0)
|
|
|
|
align->position = position;
|
|
|
|
else
|
|
|
|
die(_("unrecognized %%(align) argument: %s"), s);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (width == ~0U)
|
|
|
|
die(_("positive width expected with the %%(align) atom"));
|
|
|
|
align->width = width;
|
|
|
|
string_list_clear(¶ms, 0);
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void if_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2017-01-10 08:49:36 +00:00
|
|
|
{
|
|
|
|
if (!arg) {
|
|
|
|
atom->u.if_then_else.cmp_status = COMPARE_NONE;
|
|
|
|
return;
|
|
|
|
} else if (skip_prefix(arg, "equals=", &atom->u.if_then_else.str)) {
|
|
|
|
atom->u.if_then_else.cmp_status = COMPARE_EQUAL;
|
|
|
|
} else if (skip_prefix(arg, "notequals=", &atom->u.if_then_else.str)) {
|
|
|
|
atom->u.if_then_else.cmp_status = COMPARE_UNEQUAL;
|
|
|
|
} else {
|
|
|
|
die(_("unrecognized %%(if) argument: %s"), arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:06:40 +00:00
|
|
|
static void head_atom_parser(const struct ref_format *format, struct used_atom *atom, const char *arg)
|
2017-05-19 06:12:12 +00:00
|
|
|
{
|
2017-05-29 03:34:50 +00:00
|
|
|
struct object_id unused;
|
2017-05-19 06:12:12 +00:00
|
|
|
|
2017-05-29 03:34:50 +00:00
|
|
|
atom->u.head = resolve_refdup("HEAD", RESOLVE_REF_READING, unused.hash, NULL);
|
2017-05-19 06:12:12 +00:00
|
|
|
}
|
2017-01-10 08:49:36 +00:00
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
static struct {
|
|
|
|
const char *name;
|
|
|
|
cmp_type cmp_type;
|
2017-07-13 15:06:40 +00:00
|
|
|
void (*parser)(const struct ref_format *format, struct used_atom *atom, const char *arg);
|
2015-06-13 19:37:27 +00:00
|
|
|
} valid_atom[] = {
|
2017-01-10 08:49:44 +00:00
|
|
|
{ "refname" , FIELD_STR, refname_atom_parser },
|
2015-06-13 19:37:27 +00:00
|
|
|
{ "objecttype" },
|
|
|
|
{ "objectsize", FIELD_ULONG },
|
2016-02-17 18:06:19 +00:00
|
|
|
{ "objectname", FIELD_STR, objectname_atom_parser },
|
2015-06-13 19:37:27 +00:00
|
|
|
{ "tree" },
|
|
|
|
{ "parent" },
|
|
|
|
{ "numparent", FIELD_ULONG },
|
|
|
|
{ "object" },
|
|
|
|
{ "type" },
|
|
|
|
{ "tag" },
|
|
|
|
{ "author" },
|
|
|
|
{ "authorname" },
|
|
|
|
{ "authoremail" },
|
|
|
|
{ "authordate", FIELD_TIME },
|
|
|
|
{ "committer" },
|
|
|
|
{ "committername" },
|
|
|
|
{ "committeremail" },
|
|
|
|
{ "committerdate", FIELD_TIME },
|
|
|
|
{ "tagger" },
|
|
|
|
{ "taggername" },
|
|
|
|
{ "taggeremail" },
|
|
|
|
{ "taggerdate", FIELD_TIME },
|
|
|
|
{ "creator" },
|
|
|
|
{ "creatordate", FIELD_TIME },
|
2016-02-17 18:06:18 +00:00
|
|
|
{ "subject", FIELD_STR, subject_atom_parser },
|
|
|
|
{ "body", FIELD_STR, body_atom_parser },
|
2016-11-19 00:58:15 +00:00
|
|
|
{ "trailers", FIELD_STR, trailers_atom_parser },
|
2016-02-17 18:06:18 +00:00
|
|
|
{ "contents", FIELD_STR, contents_atom_parser },
|
2016-02-17 18:06:17 +00:00
|
|
|
{ "upstream", FIELD_STR, remote_ref_atom_parser },
|
|
|
|
{ "push", FIELD_STR, remote_ref_atom_parser },
|
2017-01-10 08:49:44 +00:00
|
|
|
{ "symref", FIELD_STR, refname_atom_parser },
|
2015-06-13 19:37:27 +00:00
|
|
|
{ "flag" },
|
2017-05-19 06:12:12 +00:00
|
|
|
{ "HEAD", FIELD_STR, head_atom_parser },
|
2016-02-17 18:06:13 +00:00
|
|
|
{ "color", FIELD_STR, color_atom_parser },
|
2016-02-17 18:06:15 +00:00
|
|
|
{ "align", FIELD_STR, align_atom_parser },
|
2015-09-11 15:03:07 +00:00
|
|
|
{ "end" },
|
2017-01-10 08:49:36 +00:00
|
|
|
{ "if", FIELD_STR, if_atom_parser },
|
2017-01-10 08:49:34 +00:00
|
|
|
{ "then" },
|
|
|
|
{ "else" },
|
2015-06-13 19:37:27 +00:00
|
|
|
};
|
|
|
|
|
2015-09-10 15:48:18 +00:00
|
|
|
#define REF_FORMATTING_STATE_INIT { 0, NULL }
|
|
|
|
|
|
|
|
struct ref_formatting_stack {
|
|
|
|
struct ref_formatting_stack *prev;
|
|
|
|
struct strbuf output;
|
2017-01-10 08:49:34 +00:00
|
|
|
void (*at_end)(struct ref_formatting_stack **stack);
|
2015-09-11 15:03:07 +00:00
|
|
|
void *at_end_data;
|
2015-09-10 15:48:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ref_formatting_state {
|
|
|
|
int quote_style;
|
|
|
|
struct ref_formatting_stack *stack;
|
|
|
|
};
|
|
|
|
|
2015-08-22 03:39:37 +00:00
|
|
|
struct atom_value {
|
|
|
|
const char *s;
|
2015-09-10 15:48:20 +00:00
|
|
|
void (*handler)(struct atom_value *atomv, struct ref_formatting_state *state);
|
2017-04-20 20:52:09 +00:00
|
|
|
uintmax_t value; /* used for sorting when not FIELD_STR */
|
2017-01-10 08:49:35 +00:00
|
|
|
struct used_atom *atom;
|
2015-08-22 03:39:37 +00:00
|
|
|
};
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/*
|
|
|
|
* Used to parse format string and sort specifiers
|
|
|
|
*/
|
2017-07-13 15:06:40 +00:00
|
|
|
static int parse_ref_filter_atom(const struct ref_format *format,
|
|
|
|
const char *atom, const char *ep)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
|
|
|
const char *sp;
|
2016-02-17 18:06:12 +00:00
|
|
|
const char *arg;
|
2016-10-02 16:35:11 +00:00
|
|
|
int i, at, atom_len;
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
sp = atom;
|
|
|
|
if (*sp == '*' && sp < ep)
|
|
|
|
sp++; /* deref */
|
|
|
|
if (ep <= sp)
|
2016-02-27 06:42:04 +00:00
|
|
|
die(_("malformed field name: %.*s"), (int)(ep-atom), atom);
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
/* Do we have the atom already used elsewhere? */
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
2016-02-17 18:06:11 +00:00
|
|
|
int len = strlen(used_atom[i].name);
|
|
|
|
if (len == ep - atom && !memcmp(used_atom[i].name, atom, len))
|
2015-06-13 19:37:27 +00:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
2016-10-02 16:35:11 +00:00
|
|
|
/*
|
|
|
|
* If the atom name has a colon, strip it and everything after
|
|
|
|
* it off - it specifies the format for this entry, and
|
|
|
|
* shouldn't be used for checking against the valid_atom
|
|
|
|
* table.
|
|
|
|
*/
|
|
|
|
arg = memchr(sp, ':', ep - sp);
|
|
|
|
atom_len = (arg ? arg : ep) - sp;
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/* Is the atom a valid one? */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(valid_atom); i++) {
|
|
|
|
int len = strlen(valid_atom[i].name);
|
2016-10-02 16:35:11 +00:00
|
|
|
if (len == atom_len && !memcmp(valid_atom[i].name, sp, len))
|
2015-06-13 19:37:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ARRAY_SIZE(valid_atom) <= i)
|
2016-02-27 06:42:04 +00:00
|
|
|
die(_("unknown field name: %.*s"), (int)(ep-atom), atom);
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
/* Add it in, including the deref prefix */
|
|
|
|
at = used_atom_cnt;
|
|
|
|
used_atom_cnt++;
|
|
|
|
REALLOC_ARRAY(used_atom, used_atom_cnt);
|
2016-02-17 18:06:11 +00:00
|
|
|
used_atom[at].name = xmemdupz(atom, ep - atom);
|
|
|
|
used_atom[at].type = valid_atom[i].cmp_type;
|
2016-02-17 18:06:12 +00:00
|
|
|
if (arg)
|
|
|
|
arg = used_atom[at].name + (arg - atom) + 1;
|
2016-02-17 18:06:13 +00:00
|
|
|
memset(&used_atom[at].u, 0, sizeof(used_atom[at].u));
|
2016-02-17 18:06:12 +00:00
|
|
|
if (valid_atom[i].parser)
|
2017-07-13 15:06:40 +00:00
|
|
|
valid_atom[i].parser(format, &used_atom[at], arg);
|
2015-06-13 19:37:27 +00:00
|
|
|
if (*atom == '*')
|
|
|
|
need_tagged = 1;
|
2017-01-10 08:49:42 +00:00
|
|
|
if (!strcmp(valid_atom[i].name, "symref"))
|
2015-06-13 19:37:27 +00:00
|
|
|
need_symref = 1;
|
|
|
|
return at;
|
|
|
|
}
|
|
|
|
|
2015-09-10 15:48:20 +00:00
|
|
|
static void quote_formatting(struct strbuf *s, const char *str, int quote_style)
|
|
|
|
{
|
|
|
|
switch (quote_style) {
|
|
|
|
case QUOTE_NONE:
|
|
|
|
strbuf_addstr(s, str);
|
|
|
|
break;
|
|
|
|
case QUOTE_SHELL:
|
|
|
|
sq_quote_buf(s, str);
|
|
|
|
break;
|
|
|
|
case QUOTE_PERL:
|
|
|
|
perl_quote_buf(s, str);
|
|
|
|
break;
|
|
|
|
case QUOTE_PYTHON:
|
|
|
|
python_quote_buf(s, str);
|
|
|
|
break;
|
|
|
|
case QUOTE_TCL:
|
|
|
|
tcl_quote_buf(s, str);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void append_atom(struct atom_value *v, struct ref_formatting_state *state)
|
|
|
|
{
|
2015-09-11 15:03:07 +00:00
|
|
|
/*
|
|
|
|
* Quote formatting is only done when the stack has a single
|
|
|
|
* element. Otherwise quote formatting is done on the
|
|
|
|
* element's entire output strbuf when the %(end) atom is
|
|
|
|
* encountered.
|
|
|
|
*/
|
|
|
|
if (!state->stack->prev)
|
|
|
|
quote_formatting(&state->stack->output, v->s, state->quote_style);
|
|
|
|
else
|
|
|
|
strbuf_addstr(&state->stack->output, v->s);
|
2015-09-10 15:48:20 +00:00
|
|
|
}
|
|
|
|
|
2015-09-10 15:48:18 +00:00
|
|
|
static void push_stack_element(struct ref_formatting_stack **stack)
|
|
|
|
{
|
|
|
|
struct ref_formatting_stack *s = xcalloc(1, sizeof(struct ref_formatting_stack));
|
|
|
|
|
|
|
|
strbuf_init(&s->output, 0);
|
|
|
|
s->prev = *stack;
|
|
|
|
*stack = s;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pop_stack_element(struct ref_formatting_stack **stack)
|
|
|
|
{
|
|
|
|
struct ref_formatting_stack *current = *stack;
|
|
|
|
struct ref_formatting_stack *prev = current->prev;
|
|
|
|
|
|
|
|
if (prev)
|
|
|
|
strbuf_addbuf(&prev->output, ¤t->output);
|
|
|
|
strbuf_release(¤t->output);
|
|
|
|
free(current);
|
|
|
|
*stack = prev;
|
|
|
|
}
|
|
|
|
|
2017-01-10 08:49:34 +00:00
|
|
|
static void end_align_handler(struct ref_formatting_stack **stack)
|
2015-09-11 15:03:07 +00:00
|
|
|
{
|
2017-01-10 08:49:34 +00:00
|
|
|
struct ref_formatting_stack *cur = *stack;
|
|
|
|
struct align *align = (struct align *)cur->at_end_data;
|
2015-09-11 15:03:07 +00:00
|
|
|
struct strbuf s = STRBUF_INIT;
|
|
|
|
|
2017-01-10 08:49:34 +00:00
|
|
|
strbuf_utf8_align(&s, align->position, align->width, cur->output.buf);
|
|
|
|
strbuf_swap(&cur->output, &s);
|
2015-09-11 15:03:07 +00:00
|
|
|
strbuf_release(&s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void align_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
|
|
|
{
|
|
|
|
struct ref_formatting_stack *new;
|
|
|
|
|
|
|
|
push_stack_element(&state->stack);
|
|
|
|
new = state->stack;
|
|
|
|
new->at_end = end_align_handler;
|
2017-01-10 08:49:35 +00:00
|
|
|
new->at_end_data = &atomv->atom->u.align;
|
2015-09-11 15:03:07 +00:00
|
|
|
}
|
|
|
|
|
2017-01-10 08:49:34 +00:00
|
|
|
static void if_then_else_handler(struct ref_formatting_stack **stack)
|
|
|
|
{
|
|
|
|
struct ref_formatting_stack *cur = *stack;
|
|
|
|
struct ref_formatting_stack *prev = cur->prev;
|
|
|
|
struct if_then_else *if_then_else = (struct if_then_else *)cur->at_end_data;
|
|
|
|
|
|
|
|
if (!if_then_else->then_atom_seen)
|
|
|
|
die(_("format: %%(if) atom used without a %%(then) atom"));
|
|
|
|
|
|
|
|
if (if_then_else->else_atom_seen) {
|
|
|
|
/*
|
|
|
|
* There is an %(else) atom: we need to drop one state from the
|
|
|
|
* stack, either the %(else) branch if the condition is satisfied, or
|
|
|
|
* the %(then) branch if it isn't.
|
|
|
|
*/
|
|
|
|
if (if_then_else->condition_satisfied) {
|
|
|
|
strbuf_reset(&cur->output);
|
|
|
|
pop_stack_element(&cur);
|
|
|
|
} else {
|
|
|
|
strbuf_swap(&cur->output, &prev->output);
|
|
|
|
strbuf_reset(&cur->output);
|
|
|
|
pop_stack_element(&cur);
|
|
|
|
}
|
|
|
|
} else if (!if_then_else->condition_satisfied) {
|
|
|
|
/*
|
|
|
|
* No %(else) atom: just drop the %(then) branch if the
|
|
|
|
* condition is not satisfied.
|
|
|
|
*/
|
|
|
|
strbuf_reset(&cur->output);
|
|
|
|
}
|
|
|
|
|
|
|
|
*stack = cur;
|
|
|
|
free(if_then_else);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void if_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
|
|
|
{
|
|
|
|
struct ref_formatting_stack *new;
|
|
|
|
struct if_then_else *if_then_else = xcalloc(sizeof(struct if_then_else), 1);
|
|
|
|
|
2017-01-10 08:49:36 +00:00
|
|
|
if_then_else->str = atomv->atom->u.if_then_else.str;
|
|
|
|
if_then_else->cmp_status = atomv->atom->u.if_then_else.cmp_status;
|
|
|
|
|
2017-01-10 08:49:34 +00:00
|
|
|
push_stack_element(&state->stack);
|
|
|
|
new = state->stack;
|
|
|
|
new->at_end = if_then_else_handler;
|
|
|
|
new->at_end_data = if_then_else;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int is_empty(const char *s)
|
|
|
|
{
|
|
|
|
while (*s != '\0') {
|
|
|
|
if (!isspace(*s))
|
|
|
|
return 0;
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void then_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
|
|
|
{
|
|
|
|
struct ref_formatting_stack *cur = state->stack;
|
|
|
|
struct if_then_else *if_then_else = NULL;
|
|
|
|
|
|
|
|
if (cur->at_end == if_then_else_handler)
|
|
|
|
if_then_else = (struct if_then_else *)cur->at_end_data;
|
|
|
|
if (!if_then_else)
|
|
|
|
die(_("format: %%(then) atom used without an %%(if) atom"));
|
|
|
|
if (if_then_else->then_atom_seen)
|
|
|
|
die(_("format: %%(then) atom used more than once"));
|
|
|
|
if (if_then_else->else_atom_seen)
|
|
|
|
die(_("format: %%(then) atom used after %%(else)"));
|
|
|
|
if_then_else->then_atom_seen = 1;
|
|
|
|
/*
|
2017-01-10 08:49:36 +00:00
|
|
|
* If the 'equals' or 'notequals' attribute is used then
|
|
|
|
* perform the required comparison. If not, only non-empty
|
|
|
|
* strings satisfy the 'if' condition.
|
2017-01-10 08:49:34 +00:00
|
|
|
*/
|
2017-01-10 08:49:36 +00:00
|
|
|
if (if_then_else->cmp_status == COMPARE_EQUAL) {
|
|
|
|
if (!strcmp(if_then_else->str, cur->output.buf))
|
|
|
|
if_then_else->condition_satisfied = 1;
|
|
|
|
} else if (if_then_else->cmp_status == COMPARE_UNEQUAL) {
|
|
|
|
if (strcmp(if_then_else->str, cur->output.buf))
|
|
|
|
if_then_else->condition_satisfied = 1;
|
|
|
|
} else if (cur->output.len && !is_empty(cur->output.buf))
|
2017-01-10 08:49:34 +00:00
|
|
|
if_then_else->condition_satisfied = 1;
|
|
|
|
strbuf_reset(&cur->output);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void else_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
|
|
|
{
|
|
|
|
struct ref_formatting_stack *prev = state->stack;
|
|
|
|
struct if_then_else *if_then_else = NULL;
|
|
|
|
|
|
|
|
if (prev->at_end == if_then_else_handler)
|
|
|
|
if_then_else = (struct if_then_else *)prev->at_end_data;
|
|
|
|
if (!if_then_else)
|
|
|
|
die(_("format: %%(else) atom used without an %%(if) atom"));
|
|
|
|
if (!if_then_else->then_atom_seen)
|
|
|
|
die(_("format: %%(else) atom used without a %%(then) atom"));
|
|
|
|
if (if_then_else->else_atom_seen)
|
|
|
|
die(_("format: %%(else) atom used more than once"));
|
|
|
|
if_then_else->else_atom_seen = 1;
|
|
|
|
push_stack_element(&state->stack);
|
|
|
|
state->stack->at_end_data = prev->at_end_data;
|
|
|
|
state->stack->at_end = prev->at_end;
|
2015-09-11 15:03:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void end_atom_handler(struct atom_value *atomv, struct ref_formatting_state *state)
|
|
|
|
{
|
|
|
|
struct ref_formatting_stack *current = state->stack;
|
|
|
|
struct strbuf s = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (!current->at_end)
|
|
|
|
die(_("format: %%(end) atom used without corresponding atom"));
|
2017-01-10 08:49:34 +00:00
|
|
|
current->at_end(&state->stack);
|
|
|
|
|
|
|
|
/* Stack may have been popped within at_end(), hence reset the current pointer */
|
|
|
|
current = state->stack;
|
2015-09-11 15:03:07 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform quote formatting when the stack element is that of
|
|
|
|
* a supporting atom. If nested then perform quote formatting
|
|
|
|
* only on the topmost supporting atom.
|
|
|
|
*/
|
2017-01-10 08:49:34 +00:00
|
|
|
if (!current->prev->prev) {
|
2015-09-11 15:03:07 +00:00
|
|
|
quote_formatting(&s, current->output.buf, state->quote_style);
|
|
|
|
strbuf_swap(¤t->output, &s);
|
|
|
|
}
|
|
|
|
strbuf_release(&s);
|
|
|
|
pop_stack_element(&state->stack);
|
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/*
|
|
|
|
* In a format string, find the next occurrence of %(atom).
|
|
|
|
*/
|
|
|
|
static const char *find_next(const char *cp)
|
|
|
|
{
|
|
|
|
while (*cp) {
|
|
|
|
if (*cp == '%') {
|
|
|
|
/*
|
|
|
|
* %( is the start of an atom;
|
|
|
|
* %% is a quoted per-cent.
|
|
|
|
*/
|
|
|
|
if (cp[1] == '(')
|
|
|
|
return cp;
|
|
|
|
else if (cp[1] == '%')
|
|
|
|
cp++; /* skip over two % */
|
|
|
|
/* otherwise this is a singleton, literal % */
|
|
|
|
}
|
|
|
|
cp++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure the format string is well formed, and parse out
|
|
|
|
* the used atoms.
|
|
|
|
*/
|
2017-07-13 15:01:18 +00:00
|
|
|
int verify_ref_format(struct ref_format *format)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
|
|
|
const char *cp, *sp;
|
|
|
|
|
2017-07-13 15:02:30 +00:00
|
|
|
format->need_color_reset_at_eol = 0;
|
2017-07-13 15:01:18 +00:00
|
|
|
for (cp = format->format; *cp && (sp = find_next(cp)); ) {
|
2015-06-13 19:37:27 +00:00
|
|
|
const char *color, *ep = strchr(sp, ')');
|
|
|
|
int at;
|
|
|
|
|
|
|
|
if (!ep)
|
2016-02-27 06:42:04 +00:00
|
|
|
return error(_("malformed format string %s"), sp);
|
2015-06-13 19:37:27 +00:00
|
|
|
/* sp points at "%(" and ep points at the closing ")" */
|
2017-07-13 15:06:40 +00:00
|
|
|
at = parse_ref_filter_atom(format, sp + 2, ep);
|
2015-06-13 19:37:27 +00:00
|
|
|
cp = ep + 1;
|
|
|
|
|
2016-02-17 18:06:11 +00:00
|
|
|
if (skip_prefix(used_atom[at].name, "color:", &color))
|
2017-07-13 15:02:30 +00:00
|
|
|
format->need_color_reset_at_eol = !!strcmp(color, "reset");
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given an object name, read the object data and size, and return a
|
|
|
|
* "struct object". If the object data we are returning is also borrowed
|
|
|
|
* by the "struct object" representation, set *eaten as well---it is a
|
|
|
|
* signal from parse_object_buffer to us not to free the buffer.
|
|
|
|
*/
|
2017-05-06 22:10:22 +00:00
|
|
|
static void *get_obj(const struct object_id *oid, struct object **obj, unsigned long *sz, int *eaten)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
|
|
|
enum object_type type;
|
2017-05-06 22:10:22 +00:00
|
|
|
void *buf = read_sha1_file(oid->hash, &type, sz);
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
if (buf)
|
object: convert parse_object* to take struct object_id
Make parse_object, parse_object_or_die, and parse_object_buffer take a
pointer to struct object_id. Remove the temporary variables inserted
earlier, since they are no longer necessary. Transform all of the
callers using the following semantic patch:
@@
expression E1;
@@
- parse_object(E1.hash)
+ parse_object(&E1)
@@
expression E1;
@@
- parse_object(E1->hash)
+ parse_object(E1)
@@
expression E1, E2;
@@
- parse_object_or_die(E1.hash, E2)
+ parse_object_or_die(&E1, E2)
@@
expression E1, E2;
@@
- parse_object_or_die(E1->hash, E2)
+ parse_object_or_die(E1, E2)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1.hash, E2, E3, E4, E5)
+ parse_object_buffer(&E1, E2, E3, E4, E5)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1->hash, E2, E3, E4, E5)
+ parse_object_buffer(E1, E2, E3, E4, E5)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:38 +00:00
|
|
|
*obj = parse_object_buffer(oid, type, *sz, buf, eaten);
|
2015-06-13 19:37:27 +00:00
|
|
|
else
|
|
|
|
*obj = NULL;
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int grab_objectname(const char *name, const unsigned char *sha1,
|
2016-02-17 18:06:19 +00:00
|
|
|
struct atom_value *v, struct used_atom *atom)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
2016-02-17 18:06:19 +00:00
|
|
|
if (starts_with(name, "objectname")) {
|
2017-01-10 08:49:37 +00:00
|
|
|
if (atom->u.objectname.option == O_SHORT) {
|
2016-02-17 18:06:19 +00:00
|
|
|
v->s = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV));
|
|
|
|
return 1;
|
2017-01-10 08:49:37 +00:00
|
|
|
} else if (atom->u.objectname.option == O_FULL) {
|
2016-02-17 18:06:19 +00:00
|
|
|
v->s = xstrdup(sha1_to_hex(sha1));
|
|
|
|
return 1;
|
2017-01-10 08:49:37 +00:00
|
|
|
} else if (atom->u.objectname.option == O_LENGTH) {
|
|
|
|
v->s = xstrdup(find_unique_abbrev(sha1, atom->u.objectname.length));
|
|
|
|
return 1;
|
2016-02-17 18:06:19 +00:00
|
|
|
} else
|
|
|
|
die("BUG: unknown %%(objectname) option");
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See grab_values */
|
|
|
|
static void grab_common_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
2016-02-17 18:06:11 +00:00
|
|
|
const char *name = used_atom[i].name;
|
2015-06-13 19:37:27 +00:00
|
|
|
struct atom_value *v = &val[i];
|
|
|
|
if (!!deref != (*name == '*'))
|
|
|
|
continue;
|
|
|
|
if (deref)
|
|
|
|
name++;
|
|
|
|
if (!strcmp(name, "objecttype"))
|
|
|
|
v->s = typename(obj->type);
|
|
|
|
else if (!strcmp(name, "objectsize")) {
|
2017-04-20 20:52:09 +00:00
|
|
|
v->value = sz;
|
2015-09-24 21:07:12 +00:00
|
|
|
v->s = xstrfmt("%lu", sz);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
else if (deref)
|
2016-02-17 18:06:19 +00:00
|
|
|
grab_objectname(name, obj->oid.hash, v, &used_atom[i]);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See grab_values */
|
|
|
|
static void grab_tag_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct tag *tag = (struct tag *) obj;
|
|
|
|
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
2016-02-17 18:06:11 +00:00
|
|
|
const char *name = used_atom[i].name;
|
2015-06-13 19:37:27 +00:00
|
|
|
struct atom_value *v = &val[i];
|
|
|
|
if (!!deref != (*name == '*'))
|
|
|
|
continue;
|
|
|
|
if (deref)
|
|
|
|
name++;
|
|
|
|
if (!strcmp(name, "tag"))
|
|
|
|
v->s = tag->tag;
|
|
|
|
else if (!strcmp(name, "type") && tag->tagged)
|
|
|
|
v->s = typename(tag->tagged->type);
|
2015-09-24 21:07:12 +00:00
|
|
|
else if (!strcmp(name, "object") && tag->tagged)
|
2015-11-10 02:22:28 +00:00
|
|
|
v->s = xstrdup(oid_to_hex(&tag->tagged->oid));
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See grab_values */
|
|
|
|
static void grab_commit_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct commit *commit = (struct commit *) obj;
|
|
|
|
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
2016-02-17 18:06:11 +00:00
|
|
|
const char *name = used_atom[i].name;
|
2015-06-13 19:37:27 +00:00
|
|
|
struct atom_value *v = &val[i];
|
|
|
|
if (!!deref != (*name == '*'))
|
|
|
|
continue;
|
|
|
|
if (deref)
|
|
|
|
name++;
|
|
|
|
if (!strcmp(name, "tree")) {
|
2015-11-10 02:22:28 +00:00
|
|
|
v->s = xstrdup(oid_to_hex(&commit->tree->object.oid));
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
2015-09-24 21:07:12 +00:00
|
|
|
else if (!strcmp(name, "numparent")) {
|
2017-04-20 20:52:09 +00:00
|
|
|
v->value = commit_list_count(commit->parents);
|
|
|
|
v->s = xstrfmt("%lu", (unsigned long)v->value);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
else if (!strcmp(name, "parent")) {
|
|
|
|
struct commit_list *parents;
|
2015-09-24 21:07:12 +00:00
|
|
|
struct strbuf s = STRBUF_INIT;
|
|
|
|
for (parents = commit->parents; parents; parents = parents->next) {
|
2015-06-13 19:37:27 +00:00
|
|
|
struct commit *parent = parents->item;
|
2015-09-24 21:07:12 +00:00
|
|
|
if (parents != commit->parents)
|
|
|
|
strbuf_addch(&s, ' ');
|
2015-11-10 02:22:28 +00:00
|
|
|
strbuf_addstr(&s, oid_to_hex(&parent->object.oid));
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
2015-09-24 21:07:12 +00:00
|
|
|
v->s = strbuf_detach(&s, NULL);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *find_wholine(const char *who, int wholen, const char *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
const char *eol;
|
|
|
|
while (*buf) {
|
|
|
|
if (!strncmp(buf, who, wholen) &&
|
|
|
|
buf[wholen] == ' ')
|
|
|
|
return buf + wholen + 1;
|
|
|
|
eol = strchr(buf, '\n');
|
|
|
|
if (!eol)
|
|
|
|
return "";
|
|
|
|
eol++;
|
|
|
|
if (*eol == '\n')
|
|
|
|
return ""; /* end of header */
|
|
|
|
buf = eol;
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *copy_line(const char *buf)
|
|
|
|
{
|
|
|
|
const char *eol = strchrnul(buf, '\n');
|
|
|
|
return xmemdupz(buf, eol - buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *copy_name(const char *buf)
|
|
|
|
{
|
|
|
|
const char *cp;
|
|
|
|
for (cp = buf; *cp && *cp != '\n'; cp++) {
|
|
|
|
if (!strncmp(cp, " <", 2))
|
|
|
|
return xmemdupz(buf, cp - buf);
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *copy_email(const char *buf)
|
|
|
|
{
|
|
|
|
const char *email = strchr(buf, '<');
|
|
|
|
const char *eoemail;
|
|
|
|
if (!email)
|
|
|
|
return "";
|
|
|
|
eoemail = strchr(email, '>');
|
|
|
|
if (!eoemail)
|
|
|
|
return "";
|
|
|
|
return xmemdupz(email, eoemail + 1 - email);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *copy_subject(const char *buf, unsigned long len)
|
|
|
|
{
|
|
|
|
char *r = xmemdupz(buf, len);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (r[i] == '\n')
|
|
|
|
r[i] = ' ';
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void grab_date(const char *buf, struct atom_value *v, const char *atomname)
|
|
|
|
{
|
|
|
|
const char *eoemail = strstr(buf, "> ");
|
|
|
|
char *zone;
|
2017-04-26 19:29:31 +00:00
|
|
|
timestamp_t timestamp;
|
2015-06-13 19:37:27 +00:00
|
|
|
long tz;
|
2015-08-03 18:01:27 +00:00
|
|
|
struct date_mode date_mode = { DATE_NORMAL };
|
2015-06-13 19:37:27 +00:00
|
|
|
const char *formatp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We got here because atomname ends in "date" or "date<something>";
|
|
|
|
* it's not possible that <something> is not ":<format>" because
|
|
|
|
* parse_ref_filter_atom() wouldn't have allowed it, so we can assume that no
|
|
|
|
* ":" means no format is specified, and use the default.
|
|
|
|
*/
|
|
|
|
formatp = strchr(atomname, ':');
|
|
|
|
if (formatp != NULL) {
|
|
|
|
formatp++;
|
2015-08-03 18:01:27 +00:00
|
|
|
parse_date_format(formatp, &date_mode);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!eoemail)
|
|
|
|
goto bad;
|
2017-04-21 10:45:44 +00:00
|
|
|
timestamp = parse_timestamp(eoemail + 2, &zone, 10);
|
2017-04-26 19:29:31 +00:00
|
|
|
if (timestamp == TIME_MAX)
|
2015-06-13 19:37:27 +00:00
|
|
|
goto bad;
|
|
|
|
tz = strtol(zone, NULL, 10);
|
|
|
|
if ((tz == LONG_MIN || tz == LONG_MAX) && errno == ERANGE)
|
|
|
|
goto bad;
|
2015-08-03 18:01:27 +00:00
|
|
|
v->s = xstrdup(show_date(timestamp, tz, &date_mode));
|
2017-04-20 20:52:09 +00:00
|
|
|
v->value = timestamp;
|
2015-06-13 19:37:27 +00:00
|
|
|
return;
|
|
|
|
bad:
|
|
|
|
v->s = "";
|
2017-04-20 20:52:09 +00:00
|
|
|
v->value = 0;
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* See grab_values */
|
|
|
|
static void grab_person(const char *who, struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int wholen = strlen(who);
|
|
|
|
const char *wholine = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
2016-02-17 18:06:11 +00:00
|
|
|
const char *name = used_atom[i].name;
|
2015-06-13 19:37:27 +00:00
|
|
|
struct atom_value *v = &val[i];
|
|
|
|
if (!!deref != (*name == '*'))
|
|
|
|
continue;
|
|
|
|
if (deref)
|
|
|
|
name++;
|
|
|
|
if (strncmp(who, name, wholen))
|
|
|
|
continue;
|
|
|
|
if (name[wholen] != 0 &&
|
|
|
|
strcmp(name + wholen, "name") &&
|
|
|
|
strcmp(name + wholen, "email") &&
|
|
|
|
!starts_with(name + wholen, "date"))
|
|
|
|
continue;
|
|
|
|
if (!wholine)
|
|
|
|
wholine = find_wholine(who, wholen, buf, sz);
|
|
|
|
if (!wholine)
|
|
|
|
return; /* no point looking for it */
|
|
|
|
if (name[wholen] == 0)
|
|
|
|
v->s = copy_line(wholine);
|
|
|
|
else if (!strcmp(name + wholen, "name"))
|
|
|
|
v->s = copy_name(wholine);
|
|
|
|
else if (!strcmp(name + wholen, "email"))
|
|
|
|
v->s = copy_email(wholine);
|
|
|
|
else if (starts_with(name + wholen, "date"))
|
|
|
|
grab_date(wholine, v, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For a tag or a commit object, if "creator" or "creatordate" is
|
|
|
|
* requested, do something special.
|
|
|
|
*/
|
|
|
|
if (strcmp(who, "tagger") && strcmp(who, "committer"))
|
|
|
|
return; /* "author" for commit object is not wanted */
|
|
|
|
if (!wholine)
|
|
|
|
wholine = find_wholine(who, wholen, buf, sz);
|
|
|
|
if (!wholine)
|
|
|
|
return;
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
2016-02-17 18:06:11 +00:00
|
|
|
const char *name = used_atom[i].name;
|
2015-06-13 19:37:27 +00:00
|
|
|
struct atom_value *v = &val[i];
|
|
|
|
if (!!deref != (*name == '*'))
|
|
|
|
continue;
|
|
|
|
if (deref)
|
|
|
|
name++;
|
|
|
|
|
|
|
|
if (starts_with(name, "creatordate"))
|
|
|
|
grab_date(wholine, v, name);
|
|
|
|
else if (!strcmp(name, "creator"))
|
|
|
|
v->s = copy_line(wholine);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void find_subpos(const char *buf, unsigned long sz,
|
|
|
|
const char **sub, unsigned long *sublen,
|
|
|
|
const char **body, unsigned long *bodylen,
|
|
|
|
unsigned long *nonsiglen,
|
|
|
|
const char **sig, unsigned long *siglen)
|
|
|
|
{
|
|
|
|
const char *eol;
|
|
|
|
/* skip past header until we hit empty line */
|
|
|
|
while (*buf && *buf != '\n') {
|
|
|
|
eol = strchrnul(buf, '\n');
|
|
|
|
if (*eol)
|
|
|
|
eol++;
|
|
|
|
buf = eol;
|
|
|
|
}
|
|
|
|
/* skip any empty lines */
|
|
|
|
while (*buf == '\n')
|
|
|
|
buf++;
|
|
|
|
|
|
|
|
/* parse signature first; we might not even have a subject line */
|
|
|
|
*sig = buf + parse_signature(buf, strlen(buf));
|
|
|
|
*siglen = strlen(*sig);
|
|
|
|
|
|
|
|
/* subject is first non-empty line */
|
|
|
|
*sub = buf;
|
|
|
|
/* subject goes to first empty line */
|
|
|
|
while (buf < *sig && *buf && *buf != '\n') {
|
|
|
|
eol = strchrnul(buf, '\n');
|
|
|
|
if (*eol)
|
|
|
|
eol++;
|
|
|
|
buf = eol;
|
|
|
|
}
|
|
|
|
*sublen = buf - *sub;
|
|
|
|
/* drop trailing newline, if present */
|
|
|
|
if (*sublen && (*sub)[*sublen - 1] == '\n')
|
|
|
|
*sublen -= 1;
|
|
|
|
|
|
|
|
/* skip any empty lines */
|
|
|
|
while (*buf == '\n')
|
|
|
|
buf++;
|
|
|
|
*body = buf;
|
|
|
|
*bodylen = strlen(buf);
|
|
|
|
*nonsiglen = *sig - buf;
|
|
|
|
}
|
|
|
|
|
2015-09-11 15:04:16 +00:00
|
|
|
/*
|
|
|
|
* If 'lines' is greater than 0, append that many lines from the given
|
|
|
|
* 'buf' of length 'size' to the given strbuf.
|
|
|
|
*/
|
|
|
|
static void append_lines(struct strbuf *out, const char *buf, unsigned long size, int lines)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
const char *sp, *eol;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
sp = buf;
|
|
|
|
|
|
|
|
for (i = 0; i < lines && sp < buf + size; i++) {
|
|
|
|
if (i)
|
|
|
|
strbuf_addstr(out, "\n ");
|
|
|
|
eol = memchr(sp, '\n', size - (sp - buf));
|
|
|
|
len = eol ? eol - sp : size - (sp - buf);
|
|
|
|
strbuf_add(out, sp, len);
|
|
|
|
if (!eol)
|
|
|
|
break;
|
|
|
|
sp = eol + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/* See grab_values */
|
|
|
|
static void grab_sub_body_contents(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
const char *subpos = NULL, *bodypos = NULL, *sigpos = NULL;
|
|
|
|
unsigned long sublen = 0, bodylen = 0, nonsiglen = 0, siglen = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
2016-02-17 18:06:18 +00:00
|
|
|
struct used_atom *atom = &used_atom[i];
|
|
|
|
const char *name = atom->name;
|
2015-06-13 19:37:27 +00:00
|
|
|
struct atom_value *v = &val[i];
|
|
|
|
if (!!deref != (*name == '*'))
|
|
|
|
continue;
|
|
|
|
if (deref)
|
|
|
|
name++;
|
|
|
|
if (strcmp(name, "subject") &&
|
|
|
|
strcmp(name, "body") &&
|
2016-11-19 00:58:15 +00:00
|
|
|
strcmp(name, "trailers") &&
|
2016-02-17 18:06:18 +00:00
|
|
|
!starts_with(name, "contents"))
|
2015-06-13 19:37:27 +00:00
|
|
|
continue;
|
|
|
|
if (!subpos)
|
|
|
|
find_subpos(buf, sz,
|
|
|
|
&subpos, &sublen,
|
|
|
|
&bodypos, &bodylen, &nonsiglen,
|
|
|
|
&sigpos, &siglen);
|
|
|
|
|
2016-02-17 18:06:18 +00:00
|
|
|
if (atom->u.contents.option == C_SUB)
|
2015-06-13 19:37:27 +00:00
|
|
|
v->s = copy_subject(subpos, sublen);
|
2016-02-17 18:06:18 +00:00
|
|
|
else if (atom->u.contents.option == C_BODY_DEP)
|
2015-06-13 19:37:27 +00:00
|
|
|
v->s = xmemdupz(bodypos, bodylen);
|
2016-02-17 18:06:18 +00:00
|
|
|
else if (atom->u.contents.option == C_BODY)
|
2015-06-13 19:37:27 +00:00
|
|
|
v->s = xmemdupz(bodypos, nonsiglen);
|
2016-02-17 18:06:18 +00:00
|
|
|
else if (atom->u.contents.option == C_SIG)
|
2015-06-13 19:37:27 +00:00
|
|
|
v->s = xmemdupz(sigpos, siglen);
|
2016-02-17 18:06:18 +00:00
|
|
|
else if (atom->u.contents.option == C_LINES) {
|
2015-09-11 15:04:16 +00:00
|
|
|
struct strbuf s = STRBUF_INIT;
|
|
|
|
const char *contents_end = bodylen + bodypos - siglen;
|
|
|
|
|
|
|
|
/* Size is the length of the message after removing the signature */
|
2016-02-17 18:06:18 +00:00
|
|
|
append_lines(&s, subpos, contents_end - subpos, atom->u.contents.nlines);
|
2015-09-11 15:04:16 +00:00
|
|
|
v->s = strbuf_detach(&s, NULL);
|
2016-11-19 00:58:15 +00:00
|
|
|
} else if (atom->u.contents.option == C_TRAILERS) {
|
|
|
|
struct trailer_info info;
|
|
|
|
|
|
|
|
/* Search for trailer info */
|
|
|
|
trailer_info_get(&info, subpos);
|
|
|
|
v->s = xmemdupz(info.trailer_start,
|
|
|
|
info.trailer_end - info.trailer_start);
|
|
|
|
trailer_info_release(&info);
|
2016-02-17 18:06:18 +00:00
|
|
|
} else if (atom->u.contents.option == C_BARE)
|
|
|
|
v->s = xstrdup(subpos);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We want to have empty print-string for field requests
|
|
|
|
* that do not apply (e.g. "authordate" for a tag object)
|
|
|
|
*/
|
|
|
|
static void fill_missing_values(struct atom_value *val)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
|
|
|
struct atom_value *v = &val[i];
|
|
|
|
if (v->s == NULL)
|
|
|
|
v->s = "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* val is a list of atom_value to hold returned values. Extract
|
|
|
|
* the values for atoms in used_atom array out of (obj, buf, sz).
|
|
|
|
* when deref is false, (obj, buf, sz) is the object that is
|
|
|
|
* pointed at by the ref itself; otherwise it is the object the
|
|
|
|
* ref (which is a tag) refers to.
|
|
|
|
*/
|
|
|
|
static void grab_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
grab_common_values(val, deref, obj, buf, sz);
|
|
|
|
switch (obj->type) {
|
|
|
|
case OBJ_TAG:
|
|
|
|
grab_tag_values(val, deref, obj, buf, sz);
|
|
|
|
grab_sub_body_contents(val, deref, obj, buf, sz);
|
|
|
|
grab_person("tagger", val, deref, obj, buf, sz);
|
|
|
|
break;
|
|
|
|
case OBJ_COMMIT:
|
|
|
|
grab_commit_values(val, deref, obj, buf, sz);
|
|
|
|
grab_sub_body_contents(val, deref, obj, buf, sz);
|
|
|
|
grab_person("author", val, deref, obj, buf, sz);
|
|
|
|
grab_person("committer", val, deref, obj, buf, sz);
|
|
|
|
break;
|
|
|
|
case OBJ_TREE:
|
|
|
|
/* grab_tree_values(val, deref, obj, buf, sz); */
|
|
|
|
break;
|
|
|
|
case OBJ_BLOB:
|
|
|
|
/* grab_blob_values(val, deref, obj, buf, sz); */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
die("Eh? Object of type %d?", obj->type);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline char *copy_advance(char *dst, const char *src)
|
|
|
|
{
|
|
|
|
while (*src)
|
|
|
|
*dst++ = *src++;
|
|
|
|
return dst;
|
|
|
|
}
|
|
|
|
|
2017-01-10 08:49:48 +00:00
|
|
|
static const char *lstrip_ref_components(const char *refname, int len)
|
tag: do not show ambiguous tag names as "tags/foo"
Since b7cc53e9 (tag.c: use 'ref-filter' APIs, 2015-07-11),
git-tag has started showing tags with ambiguous names (i.e.,
when both "heads/foo" and "tags/foo" exists) as "tags/foo"
instead of just "foo". This is both:
- pointless; the output of "git tag" includes only
refs/tags, so we know that "foo" means the one in
"refs/tags".
and
- ambiguous; in the original output, we know that the line
"foo" means that "refs/tags/foo" exists. In the new
output, it is unclear whether we mean "refs/tags/foo" or
"refs/tags/tags/foo".
The reason this happens is that commit b7cc53e9 switched
git-tag to use ref-filter's "%(refname:short)" output
formatting, which was adapted from for-each-ref. This more
general code does not know that we care only about tags, and
uses shorten_unambiguous_ref to get the short-name. We need
to tell it that we care only about "refs/tags/", and it
should shorten with respect to that value.
In theory, the ref-filter code could figure this out by us
passing FILTER_REFS_TAGS. But there are two complications
there:
1. The handling of refname:short is deep in formatting
code that does not even have our ref_filter struct, let
alone the arguments to the filter_ref struct.
2. In git v2.7.0, we expose the formatting language to the
user. If we follow this path, it will mean that
"%(refname:short)" behaves differently for "tag" versus
"for-each-ref" (including "for-each-ref refs/tags/"),
which can lead to confusion.
Instead, let's add a new modifier to the formatting
language, "strip", to remove a specific set of prefix
components. This fixes "git tag", and lets users invoke the
same behavior from their own custom formats (for "tag" or
"for-each-ref") while leaving ":short" with its same
consistent meaning in all places.
We introduce a test in t7004 for "git tag", which fails
without this patch. We also add a similar test in t3203 for
"git branch", which does not actually fail. But since it is
likely that "branch" will eventually use the same formatting
code, the test helps defend against future regressions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-26 03:00:05 +00:00
|
|
|
{
|
2017-01-10 08:49:44 +00:00
|
|
|
long remaining = len;
|
tag: do not show ambiguous tag names as "tags/foo"
Since b7cc53e9 (tag.c: use 'ref-filter' APIs, 2015-07-11),
git-tag has started showing tags with ambiguous names (i.e.,
when both "heads/foo" and "tags/foo" exists) as "tags/foo"
instead of just "foo". This is both:
- pointless; the output of "git tag" includes only
refs/tags, so we know that "foo" means the one in
"refs/tags".
and
- ambiguous; in the original output, we know that the line
"foo" means that "refs/tags/foo" exists. In the new
output, it is unclear whether we mean "refs/tags/foo" or
"refs/tags/tags/foo".
The reason this happens is that commit b7cc53e9 switched
git-tag to use ref-filter's "%(refname:short)" output
formatting, which was adapted from for-each-ref. This more
general code does not know that we care only about tags, and
uses shorten_unambiguous_ref to get the short-name. We need
to tell it that we care only about "refs/tags/", and it
should shorten with respect to that value.
In theory, the ref-filter code could figure this out by us
passing FILTER_REFS_TAGS. But there are two complications
there:
1. The handling of refname:short is deep in formatting
code that does not even have our ref_filter struct, let
alone the arguments to the filter_ref struct.
2. In git v2.7.0, we expose the formatting language to the
user. If we follow this path, it will mean that
"%(refname:short)" behaves differently for "tag" versus
"for-each-ref" (including "for-each-ref refs/tags/"),
which can lead to confusion.
Instead, let's add a new modifier to the formatting
language, "strip", to remove a specific set of prefix
components. This fixes "git tag", and lets users invoke the
same behavior from their own custom formats (for "tag" or
"for-each-ref") while leaving ":short" with its same
consistent meaning in all places.
We introduce a test in t7004 for "git tag", which fails
without this patch. We also add a similar test in t3203 for
"git branch", which does not actually fail. But since it is
likely that "branch" will eventually use the same formatting
code, the test helps defend against future regressions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-26 03:00:05 +00:00
|
|
|
const char *start = refname;
|
|
|
|
|
2017-01-10 08:49:48 +00:00
|
|
|
if (len < 0) {
|
|
|
|
int i;
|
|
|
|
const char *p = refname;
|
|
|
|
|
|
|
|
/* Find total no of '/' separated path-components */
|
|
|
|
for (i = 0; p[i]; p[i] == '/' ? i++ : *p++)
|
|
|
|
;
|
|
|
|
/*
|
|
|
|
* The number of components we need to strip is now
|
|
|
|
* the total minus the components to be left (Plus one
|
|
|
|
* because we count the number of '/', but the number
|
|
|
|
* of components is one more than the no of '/').
|
|
|
|
*/
|
|
|
|
remaining = i + len + 1;
|
|
|
|
}
|
tag: do not show ambiguous tag names as "tags/foo"
Since b7cc53e9 (tag.c: use 'ref-filter' APIs, 2015-07-11),
git-tag has started showing tags with ambiguous names (i.e.,
when both "heads/foo" and "tags/foo" exists) as "tags/foo"
instead of just "foo". This is both:
- pointless; the output of "git tag" includes only
refs/tags, so we know that "foo" means the one in
"refs/tags".
and
- ambiguous; in the original output, we know that the line
"foo" means that "refs/tags/foo" exists. In the new
output, it is unclear whether we mean "refs/tags/foo" or
"refs/tags/tags/foo".
The reason this happens is that commit b7cc53e9 switched
git-tag to use ref-filter's "%(refname:short)" output
formatting, which was adapted from for-each-ref. This more
general code does not know that we care only about tags, and
uses shorten_unambiguous_ref to get the short-name. We need
to tell it that we care only about "refs/tags/", and it
should shorten with respect to that value.
In theory, the ref-filter code could figure this out by us
passing FILTER_REFS_TAGS. But there are two complications
there:
1. The handling of refname:short is deep in formatting
code that does not even have our ref_filter struct, let
alone the arguments to the filter_ref struct.
2. In git v2.7.0, we expose the formatting language to the
user. If we follow this path, it will mean that
"%(refname:short)" behaves differently for "tag" versus
"for-each-ref" (including "for-each-ref refs/tags/"),
which can lead to confusion.
Instead, let's add a new modifier to the formatting
language, "strip", to remove a specific set of prefix
components. This fixes "git tag", and lets users invoke the
same behavior from their own custom formats (for "tag" or
"for-each-ref") while leaving ":short" with its same
consistent meaning in all places.
We introduce a test in t7004 for "git tag", which fails
without this patch. We also add a similar test in t3203 for
"git branch", which does not actually fail. But since it is
likely that "branch" will eventually use the same formatting
code, the test helps defend against future regressions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-26 03:00:05 +00:00
|
|
|
|
2017-01-10 08:49:48 +00:00
|
|
|
while (remaining > 0) {
|
tag: do not show ambiguous tag names as "tags/foo"
Since b7cc53e9 (tag.c: use 'ref-filter' APIs, 2015-07-11),
git-tag has started showing tags with ambiguous names (i.e.,
when both "heads/foo" and "tags/foo" exists) as "tags/foo"
instead of just "foo". This is both:
- pointless; the output of "git tag" includes only
refs/tags, so we know that "foo" means the one in
"refs/tags".
and
- ambiguous; in the original output, we know that the line
"foo" means that "refs/tags/foo" exists. In the new
output, it is unclear whether we mean "refs/tags/foo" or
"refs/tags/tags/foo".
The reason this happens is that commit b7cc53e9 switched
git-tag to use ref-filter's "%(refname:short)" output
formatting, which was adapted from for-each-ref. This more
general code does not know that we care only about tags, and
uses shorten_unambiguous_ref to get the short-name. We need
to tell it that we care only about "refs/tags/", and it
should shorten with respect to that value.
In theory, the ref-filter code could figure this out by us
passing FILTER_REFS_TAGS. But there are two complications
there:
1. The handling of refname:short is deep in formatting
code that does not even have our ref_filter struct, let
alone the arguments to the filter_ref struct.
2. In git v2.7.0, we expose the formatting language to the
user. If we follow this path, it will mean that
"%(refname:short)" behaves differently for "tag" versus
"for-each-ref" (including "for-each-ref refs/tags/"),
which can lead to confusion.
Instead, let's add a new modifier to the formatting
language, "strip", to remove a specific set of prefix
components. This fixes "git tag", and lets users invoke the
same behavior from their own custom formats (for "tag" or
"for-each-ref") while leaving ":short" with its same
consistent meaning in all places.
We introduce a test in t7004 for "git tag", which fails
without this patch. We also add a similar test in t3203 for
"git branch", which does not actually fail. But since it is
likely that "branch" will eventually use the same formatting
code, the test helps defend against future regressions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-26 03:00:05 +00:00
|
|
|
switch (*start++) {
|
|
|
|
case '\0':
|
2017-01-10 08:49:47 +00:00
|
|
|
return "";
|
tag: do not show ambiguous tag names as "tags/foo"
Since b7cc53e9 (tag.c: use 'ref-filter' APIs, 2015-07-11),
git-tag has started showing tags with ambiguous names (i.e.,
when both "heads/foo" and "tags/foo" exists) as "tags/foo"
instead of just "foo". This is both:
- pointless; the output of "git tag" includes only
refs/tags, so we know that "foo" means the one in
"refs/tags".
and
- ambiguous; in the original output, we know that the line
"foo" means that "refs/tags/foo" exists. In the new
output, it is unclear whether we mean "refs/tags/foo" or
"refs/tags/tags/foo".
The reason this happens is that commit b7cc53e9 switched
git-tag to use ref-filter's "%(refname:short)" output
formatting, which was adapted from for-each-ref. This more
general code does not know that we care only about tags, and
uses shorten_unambiguous_ref to get the short-name. We need
to tell it that we care only about "refs/tags/", and it
should shorten with respect to that value.
In theory, the ref-filter code could figure this out by us
passing FILTER_REFS_TAGS. But there are two complications
there:
1. The handling of refname:short is deep in formatting
code that does not even have our ref_filter struct, let
alone the arguments to the filter_ref struct.
2. In git v2.7.0, we expose the formatting language to the
user. If we follow this path, it will mean that
"%(refname:short)" behaves differently for "tag" versus
"for-each-ref" (including "for-each-ref refs/tags/"),
which can lead to confusion.
Instead, let's add a new modifier to the formatting
language, "strip", to remove a specific set of prefix
components. This fixes "git tag", and lets users invoke the
same behavior from their own custom formats (for "tag" or
"for-each-ref") while leaving ":short" with its same
consistent meaning in all places.
We introduce a test in t7004 for "git tag", which fails
without this patch. We also add a similar test in t3203 for
"git branch", which does not actually fail. But since it is
likely that "branch" will eventually use the same formatting
code, the test helps defend against future regressions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-26 03:00:05 +00:00
|
|
|
case '/':
|
|
|
|
remaining--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2017-01-10 08:49:48 +00:00
|
|
|
|
tag: do not show ambiguous tag names as "tags/foo"
Since b7cc53e9 (tag.c: use 'ref-filter' APIs, 2015-07-11),
git-tag has started showing tags with ambiguous names (i.e.,
when both "heads/foo" and "tags/foo" exists) as "tags/foo"
instead of just "foo". This is both:
- pointless; the output of "git tag" includes only
refs/tags, so we know that "foo" means the one in
"refs/tags".
and
- ambiguous; in the original output, we know that the line
"foo" means that "refs/tags/foo" exists. In the new
output, it is unclear whether we mean "refs/tags/foo" or
"refs/tags/tags/foo".
The reason this happens is that commit b7cc53e9 switched
git-tag to use ref-filter's "%(refname:short)" output
formatting, which was adapted from for-each-ref. This more
general code does not know that we care only about tags, and
uses shorten_unambiguous_ref to get the short-name. We need
to tell it that we care only about "refs/tags/", and it
should shorten with respect to that value.
In theory, the ref-filter code could figure this out by us
passing FILTER_REFS_TAGS. But there are two complications
there:
1. The handling of refname:short is deep in formatting
code that does not even have our ref_filter struct, let
alone the arguments to the filter_ref struct.
2. In git v2.7.0, we expose the formatting language to the
user. If we follow this path, it will mean that
"%(refname:short)" behaves differently for "tag" versus
"for-each-ref" (including "for-each-ref refs/tags/"),
which can lead to confusion.
Instead, let's add a new modifier to the formatting
language, "strip", to remove a specific set of prefix
components. This fixes "git tag", and lets users invoke the
same behavior from their own custom formats (for "tag" or
"for-each-ref") while leaving ":short" with its same
consistent meaning in all places.
We introduce a test in t7004 for "git tag", which fails
without this patch. We also add a similar test in t3203 for
"git branch", which does not actually fail. But since it is
likely that "branch" will eventually use the same formatting
code, the test helps defend against future regressions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-26 03:00:05 +00:00
|
|
|
return start;
|
|
|
|
}
|
|
|
|
|
2017-01-10 08:49:49 +00:00
|
|
|
static const char *rstrip_ref_components(const char *refname, int len)
|
|
|
|
{
|
|
|
|
long remaining = len;
|
|
|
|
char *start = xstrdup(refname);
|
|
|
|
|
|
|
|
if (len < 0) {
|
|
|
|
int i;
|
|
|
|
const char *p = refname;
|
|
|
|
|
|
|
|
/* Find total no of '/' separated path-components */
|
|
|
|
for (i = 0; p[i]; p[i] == '/' ? i++ : *p++)
|
|
|
|
;
|
|
|
|
/*
|
|
|
|
* The number of components we need to strip is now
|
|
|
|
* the total minus the components to be left (Plus one
|
|
|
|
* because we count the number of '/', but the number
|
|
|
|
* of components is one more than the no of '/').
|
|
|
|
*/
|
|
|
|
remaining = i + len + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (remaining-- > 0) {
|
|
|
|
char *p = strrchr(start, '/');
|
|
|
|
if (p == NULL)
|
|
|
|
return "";
|
|
|
|
else
|
|
|
|
p[0] = '\0';
|
|
|
|
}
|
|
|
|
return start;
|
|
|
|
}
|
|
|
|
|
2017-01-10 08:49:44 +00:00
|
|
|
static const char *show_ref(struct refname_atom *atom, const char *refname)
|
|
|
|
{
|
|
|
|
if (atom->option == R_SHORT)
|
|
|
|
return shorten_unambiguous_ref(refname, warn_ambiguous_refs);
|
2017-01-10 08:49:46 +00:00
|
|
|
else if (atom->option == R_LSTRIP)
|
|
|
|
return lstrip_ref_components(refname, atom->lstrip);
|
2017-01-10 08:49:49 +00:00
|
|
|
else if (atom->option == R_RSTRIP)
|
|
|
|
return rstrip_ref_components(refname, atom->rstrip);
|
2017-01-10 08:49:44 +00:00
|
|
|
else
|
|
|
|
return refname;
|
|
|
|
}
|
|
|
|
|
2016-02-17 18:06:17 +00:00
|
|
|
static void fill_remote_ref_details(struct used_atom *atom, const char *refname,
|
|
|
|
struct branch *branch, const char **s)
|
|
|
|
{
|
|
|
|
int num_ours, num_theirs;
|
2017-01-10 08:49:45 +00:00
|
|
|
if (atom->u.remote_ref.option == RR_REF)
|
|
|
|
*s = show_ref(&atom->u.remote_ref.refname, refname);
|
2017-01-10 08:49:41 +00:00
|
|
|
else if (atom->u.remote_ref.option == RR_TRACK) {
|
2016-02-17 18:06:17 +00:00
|
|
|
if (stat_tracking_info(branch, &num_ours,
|
2017-01-10 08:49:40 +00:00
|
|
|
&num_theirs, NULL)) {
|
2017-01-10 08:49:50 +00:00
|
|
|
*s = xstrdup(msgs.gone);
|
2017-01-10 08:49:41 +00:00
|
|
|
} else if (!num_ours && !num_theirs)
|
2016-02-17 18:06:17 +00:00
|
|
|
*s = "";
|
|
|
|
else if (!num_ours)
|
2017-01-10 08:49:50 +00:00
|
|
|
*s = xstrfmt(msgs.behind, num_theirs);
|
2016-02-17 18:06:17 +00:00
|
|
|
else if (!num_theirs)
|
2017-01-10 08:49:50 +00:00
|
|
|
*s = xstrfmt(msgs.ahead, num_ours);
|
2016-02-17 18:06:17 +00:00
|
|
|
else
|
2017-01-10 08:49:50 +00:00
|
|
|
*s = xstrfmt(msgs.ahead_behind,
|
2016-02-17 18:06:17 +00:00
|
|
|
num_ours, num_theirs);
|
2017-01-10 08:49:41 +00:00
|
|
|
if (!atom->u.remote_ref.nobracket && *s[0]) {
|
|
|
|
const char *to_free = *s;
|
|
|
|
*s = xstrfmt("[%s]", *s);
|
|
|
|
free((void *)to_free);
|
|
|
|
}
|
|
|
|
} else if (atom->u.remote_ref.option == RR_TRACKSHORT) {
|
2016-02-17 18:06:17 +00:00
|
|
|
if (stat_tracking_info(branch, &num_ours,
|
|
|
|
&num_theirs, NULL))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!num_ours && !num_theirs)
|
|
|
|
*s = "=";
|
|
|
|
else if (!num_ours)
|
|
|
|
*s = "<";
|
|
|
|
else if (!num_theirs)
|
|
|
|
*s = ">";
|
|
|
|
else
|
|
|
|
*s = "<>";
|
2017-01-10 08:49:45 +00:00
|
|
|
} else
|
|
|
|
die("BUG: unhandled RR_* enum");
|
2016-02-17 18:06:17 +00:00
|
|
|
}
|
|
|
|
|
2017-01-10 08:49:38 +00:00
|
|
|
char *get_head_description(void)
|
|
|
|
{
|
|
|
|
struct strbuf desc = STRBUF_INIT;
|
|
|
|
struct wt_status_state state;
|
|
|
|
memset(&state, 0, sizeof(state));
|
|
|
|
wt_status_get_state(&state, 1);
|
|
|
|
if (state.rebase_in_progress ||
|
|
|
|
state.rebase_interactive_in_progress)
|
|
|
|
strbuf_addf(&desc, _("(no branch, rebasing %s)"),
|
|
|
|
state.branch);
|
|
|
|
else if (state.bisect_in_progress)
|
|
|
|
strbuf_addf(&desc, _("(no branch, bisect started on %s)"),
|
|
|
|
state.branch);
|
|
|
|
else if (state.detached_from) {
|
|
|
|
if (state.detached_at)
|
C style: use standard style for "TRANSLATORS" comments
Change all the "TRANSLATORS: [...]" comments in the C code to use the
regular Git coding style, and amend the style guide so that the
example there uses that style.
This custom style was necessary back in 2010 when the gettext support
was initially added, and was subsequently documented in commit
cbcfd4e3ea ("i18n: mention "TRANSLATORS:" marker in
Documentation/CodingGuidelines", 2014-04-18).
GNU xgettext hasn't had the parsing limitation that necessitated this
exception for almost 3 years. Since its 0.19 release on 2014-06-02
it's been able to recognize TRANSLATOR comments in the standard Git
comment syntax[1].
Usually we'd like to keep compatibility with software that's that
young, but in this case literally the only person who needs to be
using a gettext newer than 3 years old is Jiang Xin (the only person
who runs & commits "make pot" results), so I think in this case we can
make an exception.
This xgettext parsing feature was added after a thread on the Git
mailing list[2] which continued on the bug-gettext[3] list, but we
never subsequently changed our style & styleguide, do so.
There are already longstanding changes in git that use the standard
comment style & have their TRANSLATORS comments extracted properly
without getting the literal "*"'s mixed up in the text, as would
happen before xgettext 0.19.
Commit 7ff2683253 ("builtin-am: implement -i/--interactive",
2015-08-04) added one such comment, which in commit df0617bfa7 ("l10n:
git.pot: v2.6.0 round 1 (123 new, 41 removed)", 2015-09-05) got picked
up in the po/git.pot file with the right format, showing that Jiang
already runs a modern xgettext.
The xgettext parser does not handle the sort of non-standard comment
style that I'm amending here in sequencer.c, but that isn't standard
Git comment syntax anyway. With this change to sequencer.c & "make
pot" the comment in the pot file is now correct:
#. TRANSLATORS: %s will be "revert", "cherry-pick" or
-#. * "rebase -i".
+#. "rebase -i".
1. http://git.savannah.gnu.org/cgit/gettext.git/commit/?id=10af7fe6bd
2. <2ce9ec406501d112e032c8208417f8100bed04c6.1397712142.git.worldhello.net@gmail.com>
(https://public-inbox.org/git/2ce9ec406501d112e032c8208417f8100bed04c6.1397712142.git.worldhello.net@gmail.com/)
3. https://lists.gnu.org/archive/html/bug-gettext/2014-04/msg00016.html
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Acked-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-11 21:20:12 +00:00
|
|
|
/*
|
|
|
|
* TRANSLATORS: make sure this matches "HEAD
|
|
|
|
* detached at " in wt-status.c
|
|
|
|
*/
|
2017-01-10 08:49:38 +00:00
|
|
|
strbuf_addf(&desc, _("(HEAD detached at %s)"),
|
|
|
|
state.detached_from);
|
|
|
|
else
|
C style: use standard style for "TRANSLATORS" comments
Change all the "TRANSLATORS: [...]" comments in the C code to use the
regular Git coding style, and amend the style guide so that the
example there uses that style.
This custom style was necessary back in 2010 when the gettext support
was initially added, and was subsequently documented in commit
cbcfd4e3ea ("i18n: mention "TRANSLATORS:" marker in
Documentation/CodingGuidelines", 2014-04-18).
GNU xgettext hasn't had the parsing limitation that necessitated this
exception for almost 3 years. Since its 0.19 release on 2014-06-02
it's been able to recognize TRANSLATOR comments in the standard Git
comment syntax[1].
Usually we'd like to keep compatibility with software that's that
young, but in this case literally the only person who needs to be
using a gettext newer than 3 years old is Jiang Xin (the only person
who runs & commits "make pot" results), so I think in this case we can
make an exception.
This xgettext parsing feature was added after a thread on the Git
mailing list[2] which continued on the bug-gettext[3] list, but we
never subsequently changed our style & styleguide, do so.
There are already longstanding changes in git that use the standard
comment style & have their TRANSLATORS comments extracted properly
without getting the literal "*"'s mixed up in the text, as would
happen before xgettext 0.19.
Commit 7ff2683253 ("builtin-am: implement -i/--interactive",
2015-08-04) added one such comment, which in commit df0617bfa7 ("l10n:
git.pot: v2.6.0 round 1 (123 new, 41 removed)", 2015-09-05) got picked
up in the po/git.pot file with the right format, showing that Jiang
already runs a modern xgettext.
The xgettext parser does not handle the sort of non-standard comment
style that I'm amending here in sequencer.c, but that isn't standard
Git comment syntax anyway. With this change to sequencer.c & "make
pot" the comment in the pot file is now correct:
#. TRANSLATORS: %s will be "revert", "cherry-pick" or
-#. * "rebase -i".
+#. "rebase -i".
1. http://git.savannah.gnu.org/cgit/gettext.git/commit/?id=10af7fe6bd
2. <2ce9ec406501d112e032c8208417f8100bed04c6.1397712142.git.worldhello.net@gmail.com>
(https://public-inbox.org/git/2ce9ec406501d112e032c8208417f8100bed04c6.1397712142.git.worldhello.net@gmail.com/)
3. https://lists.gnu.org/archive/html/bug-gettext/2014-04/msg00016.html
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Acked-by: Jiang Xin <worldhello.net@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-11 21:20:12 +00:00
|
|
|
/*
|
|
|
|
* TRANSLATORS: make sure this matches "HEAD
|
|
|
|
* detached from " in wt-status.c
|
|
|
|
*/
|
2017-01-10 08:49:38 +00:00
|
|
|
strbuf_addf(&desc, _("(HEAD detached from %s)"),
|
|
|
|
state.detached_from);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
strbuf_addstr(&desc, _("(no branch)"));
|
|
|
|
free(state.branch);
|
|
|
|
free(state.onto);
|
|
|
|
free(state.detached_from);
|
|
|
|
return strbuf_detach(&desc, NULL);
|
|
|
|
}
|
|
|
|
|
2017-01-10 08:49:44 +00:00
|
|
|
static const char *get_symref(struct used_atom *atom, struct ref_array_item *ref)
|
|
|
|
{
|
|
|
|
if (!ref->symref)
|
|
|
|
return "";
|
|
|
|
else
|
|
|
|
return show_ref(&atom->u.refname, ref->symref);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *get_refname(struct used_atom *atom, struct ref_array_item *ref)
|
|
|
|
{
|
|
|
|
if (ref->kind & FILTER_REFS_DETACHED_HEAD)
|
|
|
|
return get_head_description();
|
|
|
|
return show_ref(&atom->u.refname, ref->refname);
|
2016-02-17 18:06:17 +00:00
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/*
|
|
|
|
* Parse the object referred by ref, and grab needed value.
|
|
|
|
*/
|
|
|
|
static void populate_value(struct ref_array_item *ref)
|
|
|
|
{
|
|
|
|
void *buf;
|
|
|
|
struct object *obj;
|
|
|
|
int eaten, i;
|
|
|
|
unsigned long size;
|
2017-05-06 22:10:22 +00:00
|
|
|
const struct object_id *tagged;
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
ref->value = xcalloc(used_atom_cnt, sizeof(struct atom_value));
|
|
|
|
|
|
|
|
if (need_symref && (ref->flag & REF_ISSYMREF) && !ref->symref) {
|
2017-02-21 23:47:29 +00:00
|
|
|
struct object_id unused1;
|
2015-06-13 19:37:27 +00:00
|
|
|
ref->symref = resolve_refdup(ref->refname, RESOLVE_REF_READING,
|
2017-02-21 23:47:29 +00:00
|
|
|
unused1.hash, NULL);
|
2015-06-13 19:37:27 +00:00
|
|
|
if (!ref->symref)
|
|
|
|
ref->symref = "";
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill in specials first */
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
2016-02-17 18:06:13 +00:00
|
|
|
struct used_atom *atom = &used_atom[i];
|
2016-02-17 18:06:11 +00:00
|
|
|
const char *name = used_atom[i].name;
|
2015-06-13 19:37:27 +00:00
|
|
|
struct atom_value *v = &ref->value[i];
|
|
|
|
int deref = 0;
|
|
|
|
const char *refname;
|
|
|
|
struct branch *branch = NULL;
|
|
|
|
|
2015-09-10 15:48:20 +00:00
|
|
|
v->handler = append_atom;
|
2017-01-10 08:49:35 +00:00
|
|
|
v->atom = atom;
|
2015-09-10 15:48:20 +00:00
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
if (*name == '*') {
|
|
|
|
deref = 1;
|
|
|
|
name++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (starts_with(name, "refname"))
|
2017-01-10 08:49:44 +00:00
|
|
|
refname = get_refname(atom, ref);
|
2015-06-13 19:37:27 +00:00
|
|
|
else if (starts_with(name, "symref"))
|
2017-01-10 08:49:44 +00:00
|
|
|
refname = get_symref(atom, ref);
|
2015-06-13 19:37:27 +00:00
|
|
|
else if (starts_with(name, "upstream")) {
|
|
|
|
const char *branch_name;
|
|
|
|
/* only local branches may have an upstream */
|
|
|
|
if (!skip_prefix(ref->refname, "refs/heads/",
|
|
|
|
&branch_name))
|
|
|
|
continue;
|
|
|
|
branch = branch_get(branch_name);
|
|
|
|
|
|
|
|
refname = branch_get_upstream(branch, NULL);
|
2016-02-17 18:06:17 +00:00
|
|
|
if (refname)
|
|
|
|
fill_remote_ref_details(atom, refname, branch, &v->s);
|
|
|
|
continue;
|
2015-06-13 19:37:27 +00:00
|
|
|
} else if (starts_with(name, "push")) {
|
|
|
|
const char *branch_name;
|
|
|
|
if (!skip_prefix(ref->refname, "refs/heads/",
|
|
|
|
&branch_name))
|
|
|
|
continue;
|
|
|
|
branch = branch_get(branch_name);
|
|
|
|
|
|
|
|
refname = branch_get_push(branch, NULL);
|
|
|
|
if (!refname)
|
|
|
|
continue;
|
2016-02-17 18:06:17 +00:00
|
|
|
fill_remote_ref_details(atom, refname, branch, &v->s);
|
|
|
|
continue;
|
2016-02-17 18:06:13 +00:00
|
|
|
} else if (starts_with(name, "color:")) {
|
|
|
|
v->s = atom->u.color;
|
2015-06-13 19:37:27 +00:00
|
|
|
continue;
|
|
|
|
} else if (!strcmp(name, "flag")) {
|
|
|
|
char buf[256], *cp = buf;
|
|
|
|
if (ref->flag & REF_ISSYMREF)
|
|
|
|
cp = copy_advance(cp, ",symref");
|
|
|
|
if (ref->flag & REF_ISPACKED)
|
|
|
|
cp = copy_advance(cp, ",packed");
|
|
|
|
if (cp == buf)
|
|
|
|
v->s = "";
|
|
|
|
else {
|
|
|
|
*cp = '\0';
|
|
|
|
v->s = xstrdup(buf + 1);
|
|
|
|
}
|
|
|
|
continue;
|
2017-05-06 22:10:21 +00:00
|
|
|
} else if (!deref && grab_objectname(name, ref->objectname.hash, v, atom)) {
|
2015-06-13 19:37:27 +00:00
|
|
|
continue;
|
|
|
|
} else if (!strcmp(name, "HEAD")) {
|
2017-05-19 06:12:12 +00:00
|
|
|
if (atom->u.head && !strcmp(ref->refname, atom->u.head))
|
2015-06-13 19:37:27 +00:00
|
|
|
v->s = "*";
|
|
|
|
else
|
|
|
|
v->s = " ";
|
|
|
|
continue;
|
2016-02-17 18:06:15 +00:00
|
|
|
} else if (starts_with(name, "align")) {
|
2015-09-11 15:03:07 +00:00
|
|
|
v->handler = align_atom_handler;
|
|
|
|
continue;
|
|
|
|
} else if (!strcmp(name, "end")) {
|
|
|
|
v->handler = end_atom_handler;
|
|
|
|
continue;
|
2017-01-10 08:49:36 +00:00
|
|
|
} else if (starts_with(name, "if")) {
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
if (skip_prefix(name, "if:", &s))
|
|
|
|
v->s = xstrdup(s);
|
2017-01-10 08:49:34 +00:00
|
|
|
v->handler = if_atom_handler;
|
|
|
|
continue;
|
|
|
|
} else if (!strcmp(name, "then")) {
|
|
|
|
v->handler = then_atom_handler;
|
|
|
|
continue;
|
|
|
|
} else if (!strcmp(name, "else")) {
|
|
|
|
v->handler = else_atom_handler;
|
|
|
|
continue;
|
2015-06-13 19:37:27 +00:00
|
|
|
} else
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!deref)
|
|
|
|
v->s = refname;
|
2015-09-24 21:07:12 +00:00
|
|
|
else
|
|
|
|
v->s = xstrfmt("%s^{}", refname);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
|
|
|
struct atom_value *v = &ref->value[i];
|
|
|
|
if (v->s == NULL)
|
|
|
|
goto need_obj;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
need_obj:
|
2017-05-06 22:10:22 +00:00
|
|
|
buf = get_obj(&ref->objectname, &obj, &size, &eaten);
|
2015-06-13 19:37:27 +00:00
|
|
|
if (!buf)
|
2016-02-27 06:42:04 +00:00
|
|
|
die(_("missing object %s for %s"),
|
2017-05-06 22:10:21 +00:00
|
|
|
oid_to_hex(&ref->objectname), ref->refname);
|
2015-06-13 19:37:27 +00:00
|
|
|
if (!obj)
|
2016-02-27 06:42:04 +00:00
|
|
|
die(_("parse_object_buffer failed on %s for %s"),
|
2017-05-06 22:10:21 +00:00
|
|
|
oid_to_hex(&ref->objectname), ref->refname);
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
grab_values(ref->value, 0, obj, buf, size);
|
|
|
|
if (!eaten)
|
|
|
|
free(buf);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is no atom that wants to know about tagged
|
|
|
|
* object, we are done.
|
|
|
|
*/
|
|
|
|
if (!need_tagged || (obj->type != OBJ_TAG))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If it is a tag object, see if we use a value that derefs
|
|
|
|
* the object, and if we do grab the object it refers to.
|
|
|
|
*/
|
2017-05-06 22:10:22 +00:00
|
|
|
tagged = &((struct tag *)obj)->tagged->oid;
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* NEEDSWORK: This derefs tag only once, which
|
|
|
|
* is good to deal with chains of trust, but
|
|
|
|
* is not consistent with what deref_tag() does
|
|
|
|
* which peels the onion to the core.
|
|
|
|
*/
|
|
|
|
buf = get_obj(tagged, &obj, &size, &eaten);
|
|
|
|
if (!buf)
|
2016-02-27 06:42:04 +00:00
|
|
|
die(_("missing object %s for %s"),
|
2017-05-06 22:10:22 +00:00
|
|
|
oid_to_hex(tagged), ref->refname);
|
2015-06-13 19:37:27 +00:00
|
|
|
if (!obj)
|
2016-02-27 06:42:04 +00:00
|
|
|
die(_("parse_object_buffer failed on %s for %s"),
|
2017-05-06 22:10:22 +00:00
|
|
|
oid_to_hex(tagged), ref->refname);
|
2015-06-13 19:37:27 +00:00
|
|
|
grab_values(ref->value, 1, obj, buf, size);
|
|
|
|
if (!eaten)
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a ref, return the value for the atom. This lazily gets value
|
|
|
|
* out of the object by calling populate value.
|
|
|
|
*/
|
|
|
|
static void get_ref_atom_value(struct ref_array_item *ref, int atom, struct atom_value **v)
|
|
|
|
{
|
|
|
|
if (!ref->value) {
|
|
|
|
populate_value(ref);
|
|
|
|
fill_missing_values(ref->value);
|
|
|
|
}
|
|
|
|
*v = &ref->value[atom];
|
|
|
|
}
|
|
|
|
|
2017-03-09 13:29:49 +00:00
|
|
|
/*
|
|
|
|
* Unknown has to be "0" here, because that's the default value for
|
|
|
|
* contains_cache slab entries that have not yet been assigned.
|
|
|
|
*/
|
2015-07-07 16:06:16 +00:00
|
|
|
enum contains_result {
|
2017-03-09 13:29:49 +00:00
|
|
|
CONTAINS_UNKNOWN = 0,
|
|
|
|
CONTAINS_NO,
|
|
|
|
CONTAINS_YES
|
2015-07-07 16:06:16 +00:00
|
|
|
};
|
|
|
|
|
2017-03-09 13:29:49 +00:00
|
|
|
define_commit_slab(contains_cache, enum contains_result);
|
|
|
|
|
2017-03-09 13:27:55 +00:00
|
|
|
struct ref_filter_cbdata {
|
|
|
|
struct ref_array *array;
|
|
|
|
struct ref_filter *filter;
|
2017-03-09 13:29:49 +00:00
|
|
|
struct contains_cache contains_cache;
|
ref-filter: add --no-contains option to tag/branch/for-each-ref
Change the tag, branch & for-each-ref commands to have a --no-contains
option in addition to their longstanding --contains options.
This allows for finding the last-good rollout tag given a known-bad
<commit>. Given a hypothetically bad commit cf5c7253e0, the git
version to revert to can be found with this hacky two-liner:
(git tag -l 'v[0-9]*'; git tag -l --contains cf5c7253e0 'v[0-9]*') |
sort | uniq -c | grep -E '^ *1 ' | awk '{print $2}' | tail -n 10
With this new --no-contains option the same can be achieved with:
git tag -l --no-contains cf5c7253e0 'v[0-9]*' | sort | tail -n 10
As the filtering machinery is shared between the tag, branch &
for-each-ref commands, implement this for those commands too. A
practical use for this with "branch" is e.g. finding branches which
were branched off between v2.8.0 and v2.10.0:
git branch --contains v2.8.0 --no-contains v2.10.0
The "describe" command also has a --contains option, but its semantics
are unrelated to what tag/branch/for-each-ref use --contains for. A
--no-contains option for "describe" wouldn't make any sense, other
than being exactly equivalent to not supplying --contains at all,
which would be confusing at best.
Add a --without option to "tag" as an alias for --no-contains, for
consistency with --with and --contains. The --with option is
undocumented, and possibly the only user of it is
Junio (<xmqqefy71iej.fsf@gitster.mtv.corp.google.com>). But it's
trivial to support, so let's do that.
The additions to the the test suite are inverse copies of the
corresponding --contains tests. With this change --no-contains for
tag, branch & for-each-ref is just as well tested as the existing
--contains option.
In addition to those tests, add a test for "tag" which asserts that
--no-contains won't find tree/blob tags, which is slightly
unintuitive, but consistent with how --contains works & is documented.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-24 18:40:57 +00:00
|
|
|
struct contains_cache no_contains_cache;
|
2015-07-07 16:06:16 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mimicking the real stack, this stack lives on the heap, avoiding stack
|
|
|
|
* overflows.
|
|
|
|
*
|
|
|
|
* At each recursion step, the stack items points to the commits whose
|
|
|
|
* ancestors are to be inspected.
|
|
|
|
*/
|
|
|
|
struct contains_stack {
|
|
|
|
int nr, alloc;
|
|
|
|
struct contains_stack_entry {
|
|
|
|
struct commit *commit;
|
|
|
|
struct commit_list *parents;
|
|
|
|
} *contains_stack;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int in_commit_list(const struct commit_list *want, struct commit *c)
|
|
|
|
{
|
|
|
|
for (; want; want = want->next)
|
2015-11-10 02:22:28 +00:00
|
|
|
if (!oidcmp(&want->item->object.oid, &c->object.oid))
|
2015-07-07 16:06:16 +00:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Test whether the candidate or one of its parents is contained in the list.
|
|
|
|
* Do not recurse to find out, though, but return -1 if inconclusive.
|
|
|
|
*/
|
|
|
|
static enum contains_result contains_test(struct commit *candidate,
|
2017-03-09 13:29:49 +00:00
|
|
|
const struct commit_list *want,
|
|
|
|
struct contains_cache *cache)
|
2015-07-07 16:06:16 +00:00
|
|
|
{
|
2017-03-09 13:29:49 +00:00
|
|
|
enum contains_result *cached = contains_cache_at(cache, candidate);
|
|
|
|
|
|
|
|
/* If we already have the answer cached, return that. */
|
|
|
|
if (*cached)
|
|
|
|
return *cached;
|
|
|
|
|
2015-07-07 16:06:16 +00:00
|
|
|
/* or are we it? */
|
|
|
|
if (in_commit_list(want, candidate)) {
|
2017-03-09 13:29:49 +00:00
|
|
|
*cached = CONTAINS_YES;
|
2017-03-09 13:28:48 +00:00
|
|
|
return CONTAINS_YES;
|
2015-07-07 16:06:16 +00:00
|
|
|
}
|
|
|
|
|
2017-03-09 13:29:49 +00:00
|
|
|
/* Otherwise, we don't know; prepare to recurse */
|
2017-03-09 13:29:04 +00:00
|
|
|
parse_commit_or_die(candidate);
|
2017-03-09 13:28:48 +00:00
|
|
|
return CONTAINS_UNKNOWN;
|
2015-07-07 16:06:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void push_to_contains_stack(struct commit *candidate, struct contains_stack *contains_stack)
|
|
|
|
{
|
|
|
|
ALLOC_GROW(contains_stack->contains_stack, contains_stack->nr + 1, contains_stack->alloc);
|
|
|
|
contains_stack->contains_stack[contains_stack->nr].commit = candidate;
|
|
|
|
contains_stack->contains_stack[contains_stack->nr++].parents = candidate->parents;
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum contains_result contains_tag_algo(struct commit *candidate,
|
2017-03-09 13:29:49 +00:00
|
|
|
const struct commit_list *want,
|
|
|
|
struct contains_cache *cache)
|
2015-07-07 16:06:16 +00:00
|
|
|
{
|
|
|
|
struct contains_stack contains_stack = { 0, 0, NULL };
|
2017-03-09 13:29:49 +00:00
|
|
|
enum contains_result result = contains_test(candidate, want, cache);
|
2015-07-07 16:06:16 +00:00
|
|
|
|
|
|
|
if (result != CONTAINS_UNKNOWN)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
push_to_contains_stack(candidate, &contains_stack);
|
|
|
|
while (contains_stack.nr) {
|
|
|
|
struct contains_stack_entry *entry = &contains_stack.contains_stack[contains_stack.nr - 1];
|
|
|
|
struct commit *commit = entry->commit;
|
|
|
|
struct commit_list *parents = entry->parents;
|
|
|
|
|
|
|
|
if (!parents) {
|
2017-03-09 13:29:49 +00:00
|
|
|
*contains_cache_at(cache, commit) = CONTAINS_NO;
|
2015-07-07 16:06:16 +00:00
|
|
|
contains_stack.nr--;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If we just popped the stack, parents->item has been marked,
|
2017-03-09 13:28:48 +00:00
|
|
|
* therefore contains_test will return a meaningful yes/no.
|
2015-07-07 16:06:16 +00:00
|
|
|
*/
|
2017-03-09 13:29:49 +00:00
|
|
|
else switch (contains_test(parents->item, want, cache)) {
|
2015-07-07 16:06:16 +00:00
|
|
|
case CONTAINS_YES:
|
2017-03-09 13:29:49 +00:00
|
|
|
*contains_cache_at(cache, commit) = CONTAINS_YES;
|
2015-07-07 16:06:16 +00:00
|
|
|
contains_stack.nr--;
|
|
|
|
break;
|
|
|
|
case CONTAINS_NO:
|
|
|
|
entry->parents = parents->next;
|
|
|
|
break;
|
|
|
|
case CONTAINS_UNKNOWN:
|
|
|
|
push_to_contains_stack(parents->item, &contains_stack);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(contains_stack.contains_stack);
|
2017-03-09 13:29:49 +00:00
|
|
|
return contains_test(candidate, want, cache);
|
2015-07-07 16:06:16 +00:00
|
|
|
}
|
|
|
|
|
2017-03-09 13:29:49 +00:00
|
|
|
static int commit_contains(struct ref_filter *filter, struct commit *commit,
|
ref-filter: add --no-contains option to tag/branch/for-each-ref
Change the tag, branch & for-each-ref commands to have a --no-contains
option in addition to their longstanding --contains options.
This allows for finding the last-good rollout tag given a known-bad
<commit>. Given a hypothetically bad commit cf5c7253e0, the git
version to revert to can be found with this hacky two-liner:
(git tag -l 'v[0-9]*'; git tag -l --contains cf5c7253e0 'v[0-9]*') |
sort | uniq -c | grep -E '^ *1 ' | awk '{print $2}' | tail -n 10
With this new --no-contains option the same can be achieved with:
git tag -l --no-contains cf5c7253e0 'v[0-9]*' | sort | tail -n 10
As the filtering machinery is shared between the tag, branch &
for-each-ref commands, implement this for those commands too. A
practical use for this with "branch" is e.g. finding branches which
were branched off between v2.8.0 and v2.10.0:
git branch --contains v2.8.0 --no-contains v2.10.0
The "describe" command also has a --contains option, but its semantics
are unrelated to what tag/branch/for-each-ref use --contains for. A
--no-contains option for "describe" wouldn't make any sense, other
than being exactly equivalent to not supplying --contains at all,
which would be confusing at best.
Add a --without option to "tag" as an alias for --no-contains, for
consistency with --with and --contains. The --with option is
undocumented, and possibly the only user of it is
Junio (<xmqqefy71iej.fsf@gitster.mtv.corp.google.com>). But it's
trivial to support, so let's do that.
The additions to the the test suite are inverse copies of the
corresponding --contains tests. With this change --no-contains for
tag, branch & for-each-ref is just as well tested as the existing
--contains option.
In addition to those tests, add a test for "tag" which asserts that
--no-contains won't find tree/blob tags, which is slightly
unintuitive, but consistent with how --contains works & is documented.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-24 18:40:57 +00:00
|
|
|
struct commit_list *list, struct contains_cache *cache)
|
2015-07-07 16:06:16 +00:00
|
|
|
{
|
|
|
|
if (filter->with_commit_tag_algo)
|
ref-filter: add --no-contains option to tag/branch/for-each-ref
Change the tag, branch & for-each-ref commands to have a --no-contains
option in addition to their longstanding --contains options.
This allows for finding the last-good rollout tag given a known-bad
<commit>. Given a hypothetically bad commit cf5c7253e0, the git
version to revert to can be found with this hacky two-liner:
(git tag -l 'v[0-9]*'; git tag -l --contains cf5c7253e0 'v[0-9]*') |
sort | uniq -c | grep -E '^ *1 ' | awk '{print $2}' | tail -n 10
With this new --no-contains option the same can be achieved with:
git tag -l --no-contains cf5c7253e0 'v[0-9]*' | sort | tail -n 10
As the filtering machinery is shared between the tag, branch &
for-each-ref commands, implement this for those commands too. A
practical use for this with "branch" is e.g. finding branches which
were branched off between v2.8.0 and v2.10.0:
git branch --contains v2.8.0 --no-contains v2.10.0
The "describe" command also has a --contains option, but its semantics
are unrelated to what tag/branch/for-each-ref use --contains for. A
--no-contains option for "describe" wouldn't make any sense, other
than being exactly equivalent to not supplying --contains at all,
which would be confusing at best.
Add a --without option to "tag" as an alias for --no-contains, for
consistency with --with and --contains. The --with option is
undocumented, and possibly the only user of it is
Junio (<xmqqefy71iej.fsf@gitster.mtv.corp.google.com>). But it's
trivial to support, so let's do that.
The additions to the the test suite are inverse copies of the
corresponding --contains tests. With this change --no-contains for
tag, branch & for-each-ref is just as well tested as the existing
--contains option.
In addition to those tests, add a test for "tag" which asserts that
--no-contains won't find tree/blob tags, which is slightly
unintuitive, but consistent with how --contains works & is documented.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-24 18:40:57 +00:00
|
|
|
return contains_tag_algo(commit, list, cache) == CONTAINS_YES;
|
|
|
|
return is_descendant_of(commit, list);
|
2015-07-07 16:06:16 +00:00
|
|
|
}
|
|
|
|
|
2015-09-10 15:48:26 +00:00
|
|
|
/*
|
|
|
|
* Return 1 if the refname matches one of the patterns, otherwise 0.
|
|
|
|
* A pattern can be a literal prefix (e.g. a refname "refs/heads/master"
|
|
|
|
* matches a pattern "refs/heads/mas") or a wildcard (e.g. the same ref
|
|
|
|
* matches "refs/heads/mas*", too).
|
|
|
|
*/
|
2016-12-04 02:52:25 +00:00
|
|
|
static int match_pattern(const struct ref_filter *filter, const char *refname)
|
2015-09-10 15:48:26 +00:00
|
|
|
{
|
2016-12-04 02:52:25 +00:00
|
|
|
const char **patterns = filter->name_patterns;
|
|
|
|
unsigned flags = 0;
|
|
|
|
|
|
|
|
if (filter->ignore_case)
|
|
|
|
flags |= WM_CASEFOLD;
|
|
|
|
|
2015-09-10 15:48:26 +00:00
|
|
|
/*
|
|
|
|
* When no '--format' option is given we need to skip the prefix
|
|
|
|
* for matching refs of tags and branches.
|
|
|
|
*/
|
|
|
|
(void)(skip_prefix(refname, "refs/tags/", &refname) ||
|
|
|
|
skip_prefix(refname, "refs/heads/", &refname) ||
|
|
|
|
skip_prefix(refname, "refs/remotes/", &refname) ||
|
|
|
|
skip_prefix(refname, "refs/", &refname));
|
|
|
|
|
|
|
|
for (; *patterns; patterns++) {
|
2017-06-22 21:38:08 +00:00
|
|
|
if (!wildmatch(*patterns, refname, flags))
|
2015-09-10 15:48:26 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/*
|
|
|
|
* Return 1 if the refname matches one of the patterns, otherwise 0.
|
|
|
|
* A pattern can be path prefix (e.g. a refname "refs/heads/master"
|
2015-09-10 15:48:26 +00:00
|
|
|
* matches a pattern "refs/heads/" but not "refs/heads/m") or a
|
|
|
|
* wildcard (e.g. the same ref matches "refs/heads/m*", too).
|
2015-06-13 19:37:27 +00:00
|
|
|
*/
|
2016-12-04 02:52:25 +00:00
|
|
|
static int match_name_as_path(const struct ref_filter *filter, const char *refname)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
2016-12-04 02:52:25 +00:00
|
|
|
const char **pattern = filter->name_patterns;
|
2015-06-13 19:37:27 +00:00
|
|
|
int namelen = strlen(refname);
|
2016-12-04 02:52:25 +00:00
|
|
|
unsigned flags = WM_PATHNAME;
|
|
|
|
|
|
|
|
if (filter->ignore_case)
|
|
|
|
flags |= WM_CASEFOLD;
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
for (; *pattern; pattern++) {
|
|
|
|
const char *p = *pattern;
|
|
|
|
int plen = strlen(p);
|
|
|
|
|
|
|
|
if ((plen <= namelen) &&
|
|
|
|
!strncmp(refname, p, plen) &&
|
|
|
|
(refname[plen] == '\0' ||
|
|
|
|
refname[plen] == '/' ||
|
|
|
|
p[plen-1] == '/'))
|
|
|
|
return 1;
|
2017-06-22 21:38:08 +00:00
|
|
|
if (!wildmatch(p, refname, WM_PATHNAME))
|
2015-06-13 19:37:27 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-10 15:48:26 +00:00
|
|
|
/* Return 1 if the refname matches one of the patterns, otherwise 0. */
|
|
|
|
static int filter_pattern_match(struct ref_filter *filter, const char *refname)
|
|
|
|
{
|
|
|
|
if (!*filter->name_patterns)
|
|
|
|
return 1; /* No pattern always matches */
|
|
|
|
if (filter->match_as_path)
|
2016-12-04 02:52:25 +00:00
|
|
|
return match_name_as_path(filter, refname);
|
|
|
|
return match_pattern(filter, refname);
|
2015-09-10 15:48:26 +00:00
|
|
|
}
|
|
|
|
|
ref-filter: limit traversal to prefix
When we are matching refnames against a pattern, then we know that the
beginning of any refname that can match the pattern has to match the
part of the pattern up to the first glob character. For example, if
the pattern is `refs/heads/foo*bar`, then it can only match a
reference that has the prefix `refs/heads/foo`.
So pass that prefix to `for_each_fullref_in()`. This lets the ref code
avoid passing us the full set of refs, and in some cases avoid reading
them in the first place.
Note that this applies only when the `match_as_path` flag is set
(i.e., when `for-each-ref` is the caller), as the matching rules for
git-branch and git-tag are subtly different.
This could be generalized to the case of multiple patterns, but (a) it
probably doesn't come up that often, and (b) it is more awkward to
deal with multiple patterns (e.g., the patterns might not be
disjoint). So, since this is just an optimization, punt on the case of
multiple patterns.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:54 +00:00
|
|
|
/*
|
|
|
|
* Find the longest prefix of pattern we can pass to
|
|
|
|
* `for_each_fullref_in()`, namely the part of pattern preceding the
|
|
|
|
* first glob character. (Note that `for_each_fullref_in()` is
|
|
|
|
* perfectly happy working with a prefix that doesn't end at a
|
|
|
|
* pathname component boundary.)
|
|
|
|
*/
|
|
|
|
static void find_longest_prefix(struct strbuf *out, const char *pattern)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
|
|
|
|
for (p = pattern; *p && !is_glob_special(*p); p++)
|
|
|
|
;
|
|
|
|
|
|
|
|
strbuf_add(out, pattern, p - pattern);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the same as for_each_fullref_in(), but it tries to iterate
|
|
|
|
* only over the patterns we'll care about. Note that it _doesn't_ do a full
|
|
|
|
* pattern match, so the callback still has to match each ref individually.
|
|
|
|
*/
|
|
|
|
static int for_each_fullref_in_pattern(struct ref_filter *filter,
|
|
|
|
each_ref_fn cb,
|
|
|
|
void *cb_data,
|
|
|
|
int broken)
|
|
|
|
{
|
|
|
|
struct strbuf prefix = STRBUF_INIT;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!filter->match_as_path) {
|
|
|
|
/*
|
|
|
|
* in this case, the patterns are applied after
|
|
|
|
* prefixes like "refs/heads/" etc. are stripped off,
|
|
|
|
* so we have to look at everything:
|
|
|
|
*/
|
|
|
|
return for_each_fullref_in("", cb, cb_data, broken);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!filter->name_patterns[0]) {
|
|
|
|
/* no patterns; we have to look at everything */
|
|
|
|
return for_each_fullref_in("", cb, cb_data, broken);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (filter->name_patterns[1]) {
|
|
|
|
/*
|
|
|
|
* multiple patterns; in theory this could still work as long
|
|
|
|
* as the patterns are disjoint. We'd just make multiple calls
|
|
|
|
* to for_each_ref(). But if they're not disjoint, we'd end up
|
|
|
|
* reporting the same ref multiple times. So let's punt on that
|
|
|
|
* for now.
|
|
|
|
*/
|
|
|
|
return for_each_fullref_in("", cb, cb_data, broken);
|
|
|
|
}
|
|
|
|
|
|
|
|
find_longest_prefix(&prefix, filter->name_patterns[0]);
|
|
|
|
|
|
|
|
ret = for_each_fullref_in(prefix.buf, cb, cb_data, broken);
|
|
|
|
strbuf_release(&prefix);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-07-07 16:06:09 +00:00
|
|
|
/*
|
|
|
|
* Given a ref (sha1, refname), check if the ref belongs to the array
|
|
|
|
* of sha1s. If the given ref is a tag, check if the given tag points
|
|
|
|
* at one of the sha1s in the given sha1 array.
|
|
|
|
* the given sha1_array.
|
|
|
|
* NEEDSWORK:
|
|
|
|
* 1. Only a single level of inderection is obtained, we might want to
|
|
|
|
* change this to account for multiple levels (e.g. annotated tags
|
|
|
|
* pointing to annotated tags pointing to a commit.)
|
|
|
|
* 2. As the refs are cached we might know what refname peels to without
|
|
|
|
* the need to parse the object via parse_object(). peel_ref() might be a
|
|
|
|
* more efficient alternative to obtain the pointee.
|
|
|
|
*/
|
2017-03-31 01:40:00 +00:00
|
|
|
static const struct object_id *match_points_at(struct oid_array *points_at,
|
2017-03-31 01:39:57 +00:00
|
|
|
const struct object_id *oid,
|
|
|
|
const char *refname)
|
2015-07-07 16:06:09 +00:00
|
|
|
{
|
2017-03-31 01:39:57 +00:00
|
|
|
const struct object_id *tagged_oid = NULL;
|
2015-07-07 16:06:09 +00:00
|
|
|
struct object *obj;
|
|
|
|
|
2017-03-31 01:40:00 +00:00
|
|
|
if (oid_array_lookup(points_at, oid) >= 0)
|
2017-03-31 01:39:57 +00:00
|
|
|
return oid;
|
object: convert parse_object* to take struct object_id
Make parse_object, parse_object_or_die, and parse_object_buffer take a
pointer to struct object_id. Remove the temporary variables inserted
earlier, since they are no longer necessary. Transform all of the
callers using the following semantic patch:
@@
expression E1;
@@
- parse_object(E1.hash)
+ parse_object(&E1)
@@
expression E1;
@@
- parse_object(E1->hash)
+ parse_object(E1)
@@
expression E1, E2;
@@
- parse_object_or_die(E1.hash, E2)
+ parse_object_or_die(&E1, E2)
@@
expression E1, E2;
@@
- parse_object_or_die(E1->hash, E2)
+ parse_object_or_die(E1, E2)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1.hash, E2, E3, E4, E5)
+ parse_object_buffer(&E1, E2, E3, E4, E5)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1->hash, E2, E3, E4, E5)
+ parse_object_buffer(E1, E2, E3, E4, E5)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:38 +00:00
|
|
|
obj = parse_object(oid);
|
2015-07-07 16:06:09 +00:00
|
|
|
if (!obj)
|
|
|
|
die(_("malformed object at '%s'"), refname);
|
|
|
|
if (obj->type == OBJ_TAG)
|
2017-03-31 01:39:57 +00:00
|
|
|
tagged_oid = &((struct tag *)obj)->tagged->oid;
|
2017-03-31 01:40:00 +00:00
|
|
|
if (tagged_oid && oid_array_lookup(points_at, tagged_oid) >= 0)
|
2017-03-31 01:39:57 +00:00
|
|
|
return tagged_oid;
|
2015-07-07 16:06:09 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/* Allocate space for a new ref_array_item and copy the objectname and flag to it */
|
|
|
|
static struct ref_array_item *new_ref_array_item(const char *refname,
|
|
|
|
const unsigned char *objectname,
|
|
|
|
int flag)
|
|
|
|
{
|
2016-02-22 22:44:32 +00:00
|
|
|
struct ref_array_item *ref;
|
|
|
|
FLEX_ALLOC_STR(ref, refname, refname);
|
2017-05-06 22:10:21 +00:00
|
|
|
hashcpy(ref->objectname.hash, objectname);
|
2015-06-13 19:37:27 +00:00
|
|
|
ref->flag = flag;
|
|
|
|
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
|
2017-01-17 23:37:19 +00:00
|
|
|
static int ref_kind_from_refname(const char *refname)
|
2015-09-10 15:48:23 +00:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
const char *prefix;
|
|
|
|
unsigned int kind;
|
|
|
|
} ref_kind[] = {
|
|
|
|
{ "refs/heads/" , FILTER_REFS_BRANCHES },
|
|
|
|
{ "refs/remotes/" , FILTER_REFS_REMOTES },
|
|
|
|
{ "refs/tags/", FILTER_REFS_TAGS}
|
|
|
|
};
|
|
|
|
|
2017-01-17 23:37:19 +00:00
|
|
|
if (!strcmp(refname, "HEAD"))
|
2015-09-10 15:48:23 +00:00
|
|
|
return FILTER_REFS_DETACHED_HEAD;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ref_kind); i++) {
|
|
|
|
if (starts_with(refname, ref_kind[i].prefix))
|
|
|
|
return ref_kind[i].kind;
|
|
|
|
}
|
|
|
|
|
|
|
|
return FILTER_REFS_OTHERS;
|
|
|
|
}
|
|
|
|
|
2017-01-17 23:37:19 +00:00
|
|
|
static int filter_ref_kind(struct ref_filter *filter, const char *refname)
|
|
|
|
{
|
|
|
|
if (filter->kind == FILTER_REFS_BRANCHES ||
|
|
|
|
filter->kind == FILTER_REFS_REMOTES ||
|
|
|
|
filter->kind == FILTER_REFS_TAGS)
|
|
|
|
return filter->kind;
|
|
|
|
return ref_kind_from_refname(refname);
|
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/*
|
|
|
|
* A call-back given to for_each_ref(). Filter refs and keep them for
|
|
|
|
* later object processing.
|
|
|
|
*/
|
2015-06-13 19:37:28 +00:00
|
|
|
static int ref_filter_handler(const char *refname, const struct object_id *oid, int flag, void *cb_data)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
|
|
|
struct ref_filter_cbdata *ref_cbdata = cb_data;
|
2015-06-13 19:37:28 +00:00
|
|
|
struct ref_filter *filter = ref_cbdata->filter;
|
2015-06-13 19:37:27 +00:00
|
|
|
struct ref_array_item *ref;
|
2015-07-07 16:06:12 +00:00
|
|
|
struct commit *commit = NULL;
|
2015-09-10 15:48:23 +00:00
|
|
|
unsigned int kind;
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
if (flag & REF_BAD_NAME) {
|
2016-02-27 06:42:04 +00:00
|
|
|
warning(_("ignoring ref with broken name %s"), refname);
|
2015-06-13 19:37:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-03 18:01:10 +00:00
|
|
|
if (flag & REF_ISBROKEN) {
|
2016-02-27 06:42:04 +00:00
|
|
|
warning(_("ignoring broken ref %s"), refname);
|
2015-08-03 18:01:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-10 15:48:23 +00:00
|
|
|
/* Obtain the current ref kind from filter_ref_kind() and ignore unwanted refs. */
|
|
|
|
kind = filter_ref_kind(filter, refname);
|
|
|
|
if (!(kind & filter->kind))
|
|
|
|
return 0;
|
|
|
|
|
2015-09-10 15:48:26 +00:00
|
|
|
if (!filter_pattern_match(filter, refname))
|
2015-06-13 19:37:27 +00:00
|
|
|
return 0;
|
|
|
|
|
2017-03-31 01:39:57 +00:00
|
|
|
if (filter->points_at.nr && !match_points_at(&filter->points_at, oid, refname))
|
2015-07-07 16:06:09 +00:00
|
|
|
return 0;
|
|
|
|
|
2015-07-07 16:06:12 +00:00
|
|
|
/*
|
|
|
|
* A merge filter is applied on refs pointing to commits. Hence
|
|
|
|
* obtain the commit using the 'oid' available and discard all
|
|
|
|
* non-commits early. The actual filtering is done later.
|
|
|
|
*/
|
ref-filter: add --no-contains option to tag/branch/for-each-ref
Change the tag, branch & for-each-ref commands to have a --no-contains
option in addition to their longstanding --contains options.
This allows for finding the last-good rollout tag given a known-bad
<commit>. Given a hypothetically bad commit cf5c7253e0, the git
version to revert to can be found with this hacky two-liner:
(git tag -l 'v[0-9]*'; git tag -l --contains cf5c7253e0 'v[0-9]*') |
sort | uniq -c | grep -E '^ *1 ' | awk '{print $2}' | tail -n 10
With this new --no-contains option the same can be achieved with:
git tag -l --no-contains cf5c7253e0 'v[0-9]*' | sort | tail -n 10
As the filtering machinery is shared between the tag, branch &
for-each-ref commands, implement this for those commands too. A
practical use for this with "branch" is e.g. finding branches which
were branched off between v2.8.0 and v2.10.0:
git branch --contains v2.8.0 --no-contains v2.10.0
The "describe" command also has a --contains option, but its semantics
are unrelated to what tag/branch/for-each-ref use --contains for. A
--no-contains option for "describe" wouldn't make any sense, other
than being exactly equivalent to not supplying --contains at all,
which would be confusing at best.
Add a --without option to "tag" as an alias for --no-contains, for
consistency with --with and --contains. The --with option is
undocumented, and possibly the only user of it is
Junio (<xmqqefy71iej.fsf@gitster.mtv.corp.google.com>). But it's
trivial to support, so let's do that.
The additions to the the test suite are inverse copies of the
corresponding --contains tests. With this change --no-contains for
tag, branch & for-each-ref is just as well tested as the existing
--contains option.
In addition to those tests, add a test for "tag" which asserts that
--no-contains won't find tree/blob tags, which is slightly
unintuitive, but consistent with how --contains works & is documented.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-24 18:40:57 +00:00
|
|
|
if (filter->merge_commit || filter->with_commit || filter->no_commit || filter->verbose) {
|
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);
|
2015-07-07 16:06:12 +00:00
|
|
|
if (!commit)
|
|
|
|
return 0;
|
ref-filter: add --no-contains option to tag/branch/for-each-ref
Change the tag, branch & for-each-ref commands to have a --no-contains
option in addition to their longstanding --contains options.
This allows for finding the last-good rollout tag given a known-bad
<commit>. Given a hypothetically bad commit cf5c7253e0, the git
version to revert to can be found with this hacky two-liner:
(git tag -l 'v[0-9]*'; git tag -l --contains cf5c7253e0 'v[0-9]*') |
sort | uniq -c | grep -E '^ *1 ' | awk '{print $2}' | tail -n 10
With this new --no-contains option the same can be achieved with:
git tag -l --no-contains cf5c7253e0 'v[0-9]*' | sort | tail -n 10
As the filtering machinery is shared between the tag, branch &
for-each-ref commands, implement this for those commands too. A
practical use for this with "branch" is e.g. finding branches which
were branched off between v2.8.0 and v2.10.0:
git branch --contains v2.8.0 --no-contains v2.10.0
The "describe" command also has a --contains option, but its semantics
are unrelated to what tag/branch/for-each-ref use --contains for. A
--no-contains option for "describe" wouldn't make any sense, other
than being exactly equivalent to not supplying --contains at all,
which would be confusing at best.
Add a --without option to "tag" as an alias for --no-contains, for
consistency with --with and --contains. The --with option is
undocumented, and possibly the only user of it is
Junio (<xmqqefy71iej.fsf@gitster.mtv.corp.google.com>). But it's
trivial to support, so let's do that.
The additions to the the test suite are inverse copies of the
corresponding --contains tests. With this change --no-contains for
tag, branch & for-each-ref is just as well tested as the existing
--contains option.
In addition to those tests, add a test for "tag" which asserts that
--no-contains won't find tree/blob tags, which is slightly
unintuitive, but consistent with how --contains works & is documented.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-24 18:40:57 +00:00
|
|
|
/* We perform the filtering for the '--contains' option... */
|
2015-07-07 16:06:16 +00:00
|
|
|
if (filter->with_commit &&
|
ref-filter: add --no-contains option to tag/branch/for-each-ref
Change the tag, branch & for-each-ref commands to have a --no-contains
option in addition to their longstanding --contains options.
This allows for finding the last-good rollout tag given a known-bad
<commit>. Given a hypothetically bad commit cf5c7253e0, the git
version to revert to can be found with this hacky two-liner:
(git tag -l 'v[0-9]*'; git tag -l --contains cf5c7253e0 'v[0-9]*') |
sort | uniq -c | grep -E '^ *1 ' | awk '{print $2}' | tail -n 10
With this new --no-contains option the same can be achieved with:
git tag -l --no-contains cf5c7253e0 'v[0-9]*' | sort | tail -n 10
As the filtering machinery is shared between the tag, branch &
for-each-ref commands, implement this for those commands too. A
practical use for this with "branch" is e.g. finding branches which
were branched off between v2.8.0 and v2.10.0:
git branch --contains v2.8.0 --no-contains v2.10.0
The "describe" command also has a --contains option, but its semantics
are unrelated to what tag/branch/for-each-ref use --contains for. A
--no-contains option for "describe" wouldn't make any sense, other
than being exactly equivalent to not supplying --contains at all,
which would be confusing at best.
Add a --without option to "tag" as an alias for --no-contains, for
consistency with --with and --contains. The --with option is
undocumented, and possibly the only user of it is
Junio (<xmqqefy71iej.fsf@gitster.mtv.corp.google.com>). But it's
trivial to support, so let's do that.
The additions to the the test suite are inverse copies of the
corresponding --contains tests. With this change --no-contains for
tag, branch & for-each-ref is just as well tested as the existing
--contains option.
In addition to those tests, add a test for "tag" which asserts that
--no-contains won't find tree/blob tags, which is slightly
unintuitive, but consistent with how --contains works & is documented.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-24 18:40:57 +00:00
|
|
|
!commit_contains(filter, commit, filter->with_commit, &ref_cbdata->contains_cache))
|
|
|
|
return 0;
|
|
|
|
/* ...or for the `--no-contains' option */
|
|
|
|
if (filter->no_commit &&
|
|
|
|
commit_contains(filter, commit, filter->no_commit, &ref_cbdata->no_contains_cache))
|
2015-07-07 16:06:16 +00:00
|
|
|
return 0;
|
2015-07-07 16:06:12 +00:00
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/*
|
|
|
|
* We do not open the object yet; sort may only need refname
|
|
|
|
* to do its job and the resulting list may yet to be pruned
|
|
|
|
* by maxcount logic.
|
|
|
|
*/
|
|
|
|
ref = new_ref_array_item(refname, oid->hash, flag);
|
2015-07-07 16:06:12 +00:00
|
|
|
ref->commit = commit;
|
2015-06-13 19:37:27 +00:00
|
|
|
|
2015-06-13 19:37:28 +00:00
|
|
|
REALLOC_ARRAY(ref_cbdata->array->items, ref_cbdata->array->nr + 1);
|
|
|
|
ref_cbdata->array->items[ref_cbdata->array->nr++] = ref;
|
2015-09-10 15:48:23 +00:00
|
|
|
ref->kind = kind;
|
2015-06-13 19:37:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free memory allocated for a ref_array_item */
|
|
|
|
static void free_array_item(struct ref_array_item *item)
|
|
|
|
{
|
|
|
|
free((char *)item->symref);
|
|
|
|
free(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free all memory allocated for ref_array */
|
|
|
|
void ref_array_clear(struct ref_array *array)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < array->nr; i++)
|
|
|
|
free_array_item(array->items[i]);
|
2017-06-15 23:15:46 +00:00
|
|
|
FREE_AND_NULL(array->items);
|
2015-06-13 19:37:27 +00:00
|
|
|
array->nr = array->alloc = 0;
|
|
|
|
}
|
|
|
|
|
2015-07-07 16:06:12 +00:00
|
|
|
static void do_merge_filter(struct ref_filter_cbdata *ref_cbdata)
|
|
|
|
{
|
|
|
|
struct rev_info revs;
|
|
|
|
int i, old_nr;
|
|
|
|
struct ref_filter *filter = ref_cbdata->filter;
|
|
|
|
struct ref_array *array = ref_cbdata->array;
|
|
|
|
struct commit **to_clear = xcalloc(sizeof(struct commit *), array->nr);
|
|
|
|
|
|
|
|
init_revisions(&revs, NULL);
|
|
|
|
|
|
|
|
for (i = 0; i < array->nr; i++) {
|
|
|
|
struct ref_array_item *item = array->items[i];
|
|
|
|
add_pending_object(&revs, &item->commit->object, item->refname);
|
|
|
|
to_clear[i] = item->commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
filter->merge_commit->object.flags |= UNINTERESTING;
|
|
|
|
add_pending_object(&revs, &filter->merge_commit->object, "");
|
|
|
|
|
|
|
|
revs.limited = 1;
|
|
|
|
if (prepare_revision_walk(&revs))
|
|
|
|
die(_("revision walk setup failed"));
|
|
|
|
|
|
|
|
old_nr = array->nr;
|
|
|
|
array->nr = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < old_nr; i++) {
|
|
|
|
struct ref_array_item *item = array->items[i];
|
|
|
|
struct commit *commit = item->commit;
|
|
|
|
|
|
|
|
int is_merged = !!(commit->object.flags & UNINTERESTING);
|
|
|
|
|
|
|
|
if (is_merged == (filter->merge == REF_FILTER_MERGED_INCLUDE))
|
|
|
|
array->items[array->nr++] = array->items[i];
|
|
|
|
else
|
|
|
|
free_array_item(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < old_nr; i++)
|
|
|
|
clear_commit_marks(to_clear[i], ALL_REV_FLAGS);
|
|
|
|
clear_commit_marks(filter->merge_commit, ALL_REV_FLAGS);
|
|
|
|
free(to_clear);
|
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:28 +00:00
|
|
|
/*
|
|
|
|
* API for filtering a set of refs. Based on the type of refs the user
|
|
|
|
* has requested, we iterate through those refs and apply filters
|
|
|
|
* as per the given ref_filter structure and finally store the
|
|
|
|
* filtered refs in the ref_array structure.
|
|
|
|
*/
|
|
|
|
int filter_refs(struct ref_array *array, struct ref_filter *filter, unsigned int type)
|
|
|
|
{
|
|
|
|
struct ref_filter_cbdata ref_cbdata;
|
2015-07-07 16:06:12 +00:00
|
|
|
int ret = 0;
|
2015-09-10 15:48:23 +00:00
|
|
|
unsigned int broken = 0;
|
2015-06-13 19:37:28 +00:00
|
|
|
|
|
|
|
ref_cbdata.array = array;
|
|
|
|
ref_cbdata.filter = filter;
|
|
|
|
|
2015-09-10 15:48:23 +00:00
|
|
|
if (type & FILTER_REFS_INCLUDE_BROKEN)
|
|
|
|
broken = 1;
|
|
|
|
filter->kind = type & FILTER_REFS_KIND_MASK;
|
|
|
|
|
2017-03-09 13:29:49 +00:00
|
|
|
init_contains_cache(&ref_cbdata.contains_cache);
|
ref-filter: add --no-contains option to tag/branch/for-each-ref
Change the tag, branch & for-each-ref commands to have a --no-contains
option in addition to their longstanding --contains options.
This allows for finding the last-good rollout tag given a known-bad
<commit>. Given a hypothetically bad commit cf5c7253e0, the git
version to revert to can be found with this hacky two-liner:
(git tag -l 'v[0-9]*'; git tag -l --contains cf5c7253e0 'v[0-9]*') |
sort | uniq -c | grep -E '^ *1 ' | awk '{print $2}' | tail -n 10
With this new --no-contains option the same can be achieved with:
git tag -l --no-contains cf5c7253e0 'v[0-9]*' | sort | tail -n 10
As the filtering machinery is shared between the tag, branch &
for-each-ref commands, implement this for those commands too. A
practical use for this with "branch" is e.g. finding branches which
were branched off between v2.8.0 and v2.10.0:
git branch --contains v2.8.0 --no-contains v2.10.0
The "describe" command also has a --contains option, but its semantics
are unrelated to what tag/branch/for-each-ref use --contains for. A
--no-contains option for "describe" wouldn't make any sense, other
than being exactly equivalent to not supplying --contains at all,
which would be confusing at best.
Add a --without option to "tag" as an alias for --no-contains, for
consistency with --with and --contains. The --with option is
undocumented, and possibly the only user of it is
Junio (<xmqqefy71iej.fsf@gitster.mtv.corp.google.com>). But it's
trivial to support, so let's do that.
The additions to the the test suite are inverse copies of the
corresponding --contains tests. With this change --no-contains for
tag, branch & for-each-ref is just as well tested as the existing
--contains option.
In addition to those tests, add a test for "tag" which asserts that
--no-contains won't find tree/blob tags, which is slightly
unintuitive, but consistent with how --contains works & is documented.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-24 18:40:57 +00:00
|
|
|
init_contains_cache(&ref_cbdata.no_contains_cache);
|
2017-03-09 13:29:49 +00:00
|
|
|
|
2015-07-07 16:06:12 +00:00
|
|
|
/* Simple per-ref filtering */
|
2015-09-10 15:48:23 +00:00
|
|
|
if (!filter->kind)
|
2015-06-13 19:37:28 +00:00
|
|
|
die("filter_refs: invalid type");
|
2015-09-10 15:48:23 +00:00
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* For common cases where we need only branches or remotes or tags,
|
|
|
|
* we only iterate through those refs. If a mix of refs is needed,
|
|
|
|
* we iterate over all refs and filter out required refs with the help
|
|
|
|
* of filter_ref_kind().
|
|
|
|
*/
|
|
|
|
if (filter->kind == FILTER_REFS_BRANCHES)
|
|
|
|
ret = for_each_fullref_in("refs/heads/", ref_filter_handler, &ref_cbdata, broken);
|
|
|
|
else if (filter->kind == FILTER_REFS_REMOTES)
|
|
|
|
ret = for_each_fullref_in("refs/remotes/", ref_filter_handler, &ref_cbdata, broken);
|
|
|
|
else if (filter->kind == FILTER_REFS_TAGS)
|
|
|
|
ret = for_each_fullref_in("refs/tags/", ref_filter_handler, &ref_cbdata, broken);
|
|
|
|
else if (filter->kind & FILTER_REFS_ALL)
|
ref-filter: limit traversal to prefix
When we are matching refnames against a pattern, then we know that the
beginning of any refname that can match the pattern has to match the
part of the pattern up to the first glob character. For example, if
the pattern is `refs/heads/foo*bar`, then it can only match a
reference that has the prefix `refs/heads/foo`.
So pass that prefix to `for_each_fullref_in()`. This lets the ref code
avoid passing us the full set of refs, and in some cases avoid reading
them in the first place.
Note that this applies only when the `match_as_path` flag is set
(i.e., when `for-each-ref` is the caller), as the matching rules for
git-branch and git-tag are subtly different.
This could be generalized to the case of multiple patterns, but (a) it
probably doesn't come up that often, and (b) it is more awkward to
deal with multiple patterns (e.g., the patterns might not be
disjoint). So, since this is just an optimization, punt on the case of
multiple patterns.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-22 14:17:54 +00:00
|
|
|
ret = for_each_fullref_in_pattern(filter, ref_filter_handler, &ref_cbdata, broken);
|
2015-09-10 15:48:23 +00:00
|
|
|
if (!ret && (filter->kind & FILTER_REFS_DETACHED_HEAD))
|
|
|
|
head_ref(ref_filter_handler, &ref_cbdata);
|
|
|
|
}
|
|
|
|
|
2017-03-09 13:29:49 +00:00
|
|
|
clear_contains_cache(&ref_cbdata.contains_cache);
|
ref-filter: add --no-contains option to tag/branch/for-each-ref
Change the tag, branch & for-each-ref commands to have a --no-contains
option in addition to their longstanding --contains options.
This allows for finding the last-good rollout tag given a known-bad
<commit>. Given a hypothetically bad commit cf5c7253e0, the git
version to revert to can be found with this hacky two-liner:
(git tag -l 'v[0-9]*'; git tag -l --contains cf5c7253e0 'v[0-9]*') |
sort | uniq -c | grep -E '^ *1 ' | awk '{print $2}' | tail -n 10
With this new --no-contains option the same can be achieved with:
git tag -l --no-contains cf5c7253e0 'v[0-9]*' | sort | tail -n 10
As the filtering machinery is shared between the tag, branch &
for-each-ref commands, implement this for those commands too. A
practical use for this with "branch" is e.g. finding branches which
were branched off between v2.8.0 and v2.10.0:
git branch --contains v2.8.0 --no-contains v2.10.0
The "describe" command also has a --contains option, but its semantics
are unrelated to what tag/branch/for-each-ref use --contains for. A
--no-contains option for "describe" wouldn't make any sense, other
than being exactly equivalent to not supplying --contains at all,
which would be confusing at best.
Add a --without option to "tag" as an alias for --no-contains, for
consistency with --with and --contains. The --with option is
undocumented, and possibly the only user of it is
Junio (<xmqqefy71iej.fsf@gitster.mtv.corp.google.com>). But it's
trivial to support, so let's do that.
The additions to the the test suite are inverse copies of the
corresponding --contains tests. With this change --no-contains for
tag, branch & for-each-ref is just as well tested as the existing
--contains option.
In addition to those tests, add a test for "tag" which asserts that
--no-contains won't find tree/blob tags, which is slightly
unintuitive, but consistent with how --contains works & is documented.
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-24 18:40:57 +00:00
|
|
|
clear_contains_cache(&ref_cbdata.no_contains_cache);
|
2015-07-07 16:06:12 +00:00
|
|
|
|
|
|
|
/* Filters that need revision walking */
|
|
|
|
if (filter->merge_commit)
|
|
|
|
do_merge_filter(&ref_cbdata);
|
|
|
|
|
|
|
|
return ret;
|
2015-06-13 19:37:28 +00:00
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
static int cmp_ref_sorting(struct ref_sorting *s, struct ref_array_item *a, struct ref_array_item *b)
|
|
|
|
{
|
|
|
|
struct atom_value *va, *vb;
|
|
|
|
int cmp;
|
2016-02-17 18:06:11 +00:00
|
|
|
cmp_type cmp_type = used_atom[s->atom].type;
|
2016-12-04 02:52:25 +00:00
|
|
|
int (*cmp_fn)(const char *, const char *);
|
2015-06-13 19:37:27 +00:00
|
|
|
|
|
|
|
get_ref_atom_value(a, s->atom, &va);
|
|
|
|
get_ref_atom_value(b, s->atom, &vb);
|
2016-12-04 02:52:25 +00:00
|
|
|
cmp_fn = s->ignore_case ? strcasecmp : strcmp;
|
2015-09-10 15:48:25 +00:00
|
|
|
if (s->version)
|
|
|
|
cmp = versioncmp(va->s, vb->s);
|
|
|
|
else if (cmp_type == FIELD_STR)
|
2016-12-04 02:52:25 +00:00
|
|
|
cmp = cmp_fn(va->s, vb->s);
|
2015-09-10 15:48:25 +00:00
|
|
|
else {
|
2017-04-20 20:52:09 +00:00
|
|
|
if (va->value < vb->value)
|
2015-06-13 19:37:27 +00:00
|
|
|
cmp = -1;
|
2017-04-20 20:52:09 +00:00
|
|
|
else if (va->value == vb->value)
|
2016-12-04 02:52:25 +00:00
|
|
|
cmp = cmp_fn(a->refname, b->refname);
|
2015-06-13 19:37:27 +00:00
|
|
|
else
|
|
|
|
cmp = 1;
|
|
|
|
}
|
2015-09-10 15:48:25 +00:00
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
return (s->reverse) ? -cmp : cmp;
|
|
|
|
}
|
|
|
|
|
2017-01-22 17:58:07 +00:00
|
|
|
static int compare_refs(const void *a_, const void *b_, void *ref_sorting)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
|
|
|
struct ref_array_item *a = *((struct ref_array_item **)a_);
|
|
|
|
struct ref_array_item *b = *((struct ref_array_item **)b_);
|
|
|
|
struct ref_sorting *s;
|
|
|
|
|
|
|
|
for (s = ref_sorting; s; s = s->next) {
|
|
|
|
int cmp = cmp_ref_sorting(s, a, b);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ref_array_sort(struct ref_sorting *sorting, struct ref_array *array)
|
|
|
|
{
|
2017-01-22 17:58:07 +00:00
|
|
|
QSORT_S(array->items, array->nr, compare_refs, sorting);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
|
2015-09-10 15:48:18 +00:00
|
|
|
static void append_literal(const char *cp, const char *ep, struct ref_formatting_state *state)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
2015-09-10 15:48:18 +00:00
|
|
|
struct strbuf *s = &state->stack->output;
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
while (*cp && (!ep || cp < ep)) {
|
|
|
|
if (*cp == '%') {
|
|
|
|
if (cp[1] == '%')
|
|
|
|
cp++;
|
|
|
|
else {
|
2016-09-03 15:59:20 +00:00
|
|
|
int ch = hex2chr(cp + 1);
|
2015-06-13 19:37:27 +00:00
|
|
|
if (0 <= ch) {
|
2015-09-10 15:48:18 +00:00
|
|
|
strbuf_addch(s, ch);
|
2015-06-13 19:37:27 +00:00
|
|
|
cp += 3;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-09-10 15:48:18 +00:00
|
|
|
strbuf_addch(s, *cp);
|
2015-06-13 19:37:27 +00:00
|
|
|
cp++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:01:18 +00:00
|
|
|
void format_ref_array_item(struct ref_array_item *info,
|
|
|
|
const struct ref_format *format,
|
|
|
|
struct strbuf *final_buf)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
|
|
|
const char *cp, *sp, *ep;
|
2015-09-10 15:48:18 +00:00
|
|
|
struct ref_formatting_state state = REF_FORMATTING_STATE_INIT;
|
|
|
|
|
2017-07-13 15:01:18 +00:00
|
|
|
state.quote_style = format->quote_style;
|
2015-09-10 15:48:18 +00:00
|
|
|
push_stack_element(&state.stack);
|
2015-06-13 19:37:27 +00:00
|
|
|
|
2017-07-13 15:01:18 +00:00
|
|
|
for (cp = format->format; *cp && (sp = find_next(cp)); cp = ep + 1) {
|
2015-06-13 19:37:27 +00:00
|
|
|
struct atom_value *atomv;
|
|
|
|
|
|
|
|
ep = strchr(sp, ')');
|
|
|
|
if (cp < sp)
|
2015-09-10 15:48:18 +00:00
|
|
|
append_literal(cp, sp, &state);
|
2017-07-13 15:06:40 +00:00
|
|
|
get_ref_atom_value(info,
|
|
|
|
parse_ref_filter_atom(format, sp + 2, ep),
|
|
|
|
&atomv);
|
2015-09-10 15:48:20 +00:00
|
|
|
atomv->handler(atomv, &state);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
|
|
|
if (*cp) {
|
|
|
|
sp = cp + strlen(cp);
|
2015-09-10 15:48:18 +00:00
|
|
|
append_literal(cp, sp, &state);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
2017-07-13 15:02:30 +00:00
|
|
|
if (format->need_color_reset_at_eol) {
|
2015-06-13 19:37:27 +00:00
|
|
|
struct atom_value resetv;
|
2017-07-13 14:58:56 +00:00
|
|
|
resetv.s = GIT_COLOR_RESET;
|
2015-09-10 15:48:18 +00:00
|
|
|
append_atom(&resetv, &state);
|
2015-06-13 19:37:27 +00:00
|
|
|
}
|
2015-09-11 15:03:07 +00:00
|
|
|
if (state.stack->prev)
|
|
|
|
die(_("format: %%(end) atom missing"));
|
2017-01-10 08:49:39 +00:00
|
|
|
strbuf_addbuf(final_buf, &state.stack->output);
|
2015-09-10 15:48:18 +00:00
|
|
|
pop_stack_element(&state.stack);
|
2017-01-10 08:49:39 +00:00
|
|
|
}
|
|
|
|
|
2017-07-13 15:01:18 +00:00
|
|
|
void show_ref_array_item(struct ref_array_item *info,
|
|
|
|
const struct ref_format *format)
|
2017-01-10 08:49:39 +00:00
|
|
|
{
|
|
|
|
struct strbuf final_buf = STRBUF_INIT;
|
|
|
|
|
2017-07-13 15:01:18 +00:00
|
|
|
format_ref_array_item(info, format, &final_buf);
|
2017-01-10 08:49:39 +00:00
|
|
|
fwrite(final_buf.buf, 1, final_buf.len, stdout);
|
|
|
|
strbuf_release(&final_buf);
|
2015-06-13 19:37:27 +00:00
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
|
2017-01-17 23:37:19 +00:00
|
|
|
void pretty_print_ref(const char *name, const unsigned char *sha1,
|
2017-07-13 15:01:18 +00:00
|
|
|
const struct ref_format *format)
|
2017-01-17 23:37:19 +00:00
|
|
|
{
|
|
|
|
struct ref_array_item *ref_item;
|
|
|
|
ref_item = new_ref_array_item(name, sha1, 0);
|
|
|
|
ref_item->kind = ref_kind_from_refname(name);
|
2017-07-13 15:01:18 +00:00
|
|
|
show_ref_array_item(ref_item, format);
|
2017-01-17 23:37:19 +00:00
|
|
|
free_array_item(ref_item);
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:02:58 +00:00
|
|
|
static int parse_sorting_atom(const char *atom)
|
|
|
|
{
|
2017-07-13 15:06:40 +00:00
|
|
|
/*
|
|
|
|
* This parses an atom using a dummy ref_format, since we don't
|
|
|
|
* actually care about the formatting details.
|
|
|
|
*/
|
|
|
|
struct ref_format dummy = REF_FORMAT_INIT;
|
2017-07-13 15:02:58 +00:00
|
|
|
const char *end = atom + strlen(atom);
|
2017-07-13 15:06:40 +00:00
|
|
|
return parse_ref_filter_atom(&dummy, atom, end);
|
2017-07-13 15:02:58 +00:00
|
|
|
}
|
|
|
|
|
2015-06-13 19:37:27 +00:00
|
|
|
/* If no sorting option is given, use refname to sort as default */
|
|
|
|
struct ref_sorting *ref_default_sorting(void)
|
|
|
|
{
|
|
|
|
static const char cstr_name[] = "refname";
|
|
|
|
|
|
|
|
struct ref_sorting *sorting = xcalloc(1, sizeof(*sorting));
|
|
|
|
|
|
|
|
sorting->next = NULL;
|
2017-07-13 15:02:58 +00:00
|
|
|
sorting->atom = parse_sorting_atom(cstr_name);
|
2015-06-13 19:37:27 +00:00
|
|
|
return sorting;
|
|
|
|
}
|
|
|
|
|
2017-07-13 15:02:44 +00:00
|
|
|
void parse_ref_sorting(struct ref_sorting **sorting_tail, const char *arg)
|
2015-06-13 19:37:27 +00:00
|
|
|
{
|
|
|
|
struct ref_sorting *s;
|
|
|
|
|
|
|
|
s = xcalloc(1, sizeof(*s));
|
|
|
|
s->next = *sorting_tail;
|
|
|
|
*sorting_tail = s;
|
|
|
|
|
|
|
|
if (*arg == '-') {
|
|
|
|
s->reverse = 1;
|
|
|
|
arg++;
|
|
|
|
}
|
2015-09-10 15:48:25 +00:00
|
|
|
if (skip_prefix(arg, "version:", &arg) ||
|
|
|
|
skip_prefix(arg, "v:", &arg))
|
|
|
|
s->version = 1;
|
2017-07-13 15:02:58 +00:00
|
|
|
s->atom = parse_sorting_atom(arg);
|
2017-07-13 15:02:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int parse_opt_ref_sorting(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
if (!arg) /* should --no-sort void the list ? */
|
|
|
|
return -1;
|
|
|
|
parse_ref_sorting(opt->value, arg);
|
2015-06-13 19:37:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2015-07-07 16:06:11 +00:00
|
|
|
|
|
|
|
int parse_opt_merge_filter(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
struct ref_filter *rf = opt->value;
|
2017-05-06 22:10:09 +00:00
|
|
|
struct object_id oid;
|
2017-03-21 12:58:49 +00:00
|
|
|
int no_merged = starts_with(opt->long_name, "no");
|
2015-07-07 16:06:11 +00:00
|
|
|
|
2017-03-21 12:58:49 +00:00
|
|
|
if (rf->merge) {
|
|
|
|
if (no_merged) {
|
|
|
|
return opterror(opt, "is incompatible with --merged", 0);
|
|
|
|
} else {
|
|
|
|
return opterror(opt, "is incompatible with --no-merged", 0);
|
|
|
|
}
|
|
|
|
}
|
2015-07-07 16:06:11 +00:00
|
|
|
|
2017-03-21 12:58:49 +00:00
|
|
|
rf->merge = no_merged
|
2015-07-07 16:06:11 +00:00
|
|
|
? REF_FILTER_MERGED_OMIT
|
|
|
|
: REF_FILTER_MERGED_INCLUDE;
|
|
|
|
|
2017-05-06 22:10:09 +00:00
|
|
|
if (get_oid(arg, &oid))
|
2015-07-07 16:06:11 +00:00
|
|
|
die(_("malformed object name %s"), arg);
|
|
|
|
|
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
|
|
|
rf->merge_commit = lookup_commit_reference_gently(&oid, 0);
|
2015-07-07 16:06:11 +00:00
|
|
|
if (!rf->merge_commit)
|
|
|
|
return opterror(opt, "must point to a commit", 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|