mirror of
https://github.com/git/git
synced 2024-08-26 19:19:18 +00:00
![Jeff King](/assets/img/avatar_default.png)
When trying to find a .mailmap file, we will always look for it in the current directory. This makes sense in a repository with a working tree, since we'd always go to the toplevel directory at startup. But for a bare repository, it can be confusing. With an option like --git-dir (or $GIT_DIR in the environment), we don't chdir at all, and we'd read .mailmap from whatever directory you happened to be in before starting Git. (Note that --git-dir without specifying a working tree historically means "the current directory is the root of the working tree", but most bare repositories will have core.bare set these days, meaning they will realize there is no working tree at all). The documentation for gitmailmap(5) says: If the file `.mailmap` exists at the toplevel of the repository[...] which likewise reinforces the notion that we are looking in the working tree. This patch prevents us from looking for such a file when we're in a bare repository. This does break something that used to work: cd bare.git git cat-file blob HEAD:.mailmap >.mailmap git shortlog But that was never advertised in the documentation. And these days we have mailmap.blob (which defaults to HEAD:.mailmap) to do the same thing in a much cleaner way. However, there's one more interesting case: we might not have a repository at all! The git-shortlog command can be run with git-log output fed on its stdin, and it will apply the mailmap. In that case, it probably does make sense to read .mailmap from the current directory. This patch will continue to do so. That leads to one even weirder case: if you run git-shortlog to process stdin, the input _could_ be from a different repository entirely. Should we respect the in-tree .mailmap then? Probably yes. Whatever the source of the input, if shortlog is running in a repository, the documentation claims that we'd read the .mailmap from its top-level (and of course it's reasonably likely that it _is_ from the same repo, and the user just preferred to run git-log and git-shortlog separately for whatever reason). The included test covers these cases, and we now document the "no repo" case explicitly. We also add a test that confirms we find a top-level ".mailmap" even when we start in a subdirectory of the working tree. This worked both before and after this commit, but we never tested it explicitly (it works because we always chdir to the top-level of the working tree if there is one). Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
343 lines
8.3 KiB
C
343 lines
8.3 KiB
C
#include "cache.h"
|
|
#include "string-list.h"
|
|
#include "mailmap.h"
|
|
#include "object-store.h"
|
|
|
|
#define DEBUG_MAILMAP 0
|
|
#if DEBUG_MAILMAP
|
|
#define debug_mm(...) fprintf(stderr, __VA_ARGS__)
|
|
#define debug_str(X) ((X) ? (X) : "(none)")
|
|
#else
|
|
static inline void debug_mm(const char *format, ...) {}
|
|
static inline const char *debug_str(const char *s) { return s; }
|
|
#endif
|
|
|
|
const char *git_mailmap_file;
|
|
const char *git_mailmap_blob;
|
|
|
|
struct mailmap_info {
|
|
char *name;
|
|
char *email;
|
|
};
|
|
|
|
struct mailmap_entry {
|
|
/* name and email for the simple mail-only case */
|
|
char *name;
|
|
char *email;
|
|
|
|
/* name and email for the complex mail and name matching case */
|
|
struct string_list namemap;
|
|
};
|
|
|
|
static void free_mailmap_info(void *p, const char *s)
|
|
{
|
|
struct mailmap_info *mi = (struct mailmap_info *)p;
|
|
debug_mm("mailmap: -- complex: '%s' -> '%s' <%s>\n",
|
|
s, debug_str(mi->name), debug_str(mi->email));
|
|
free(mi->name);
|
|
free(mi->email);
|
|
}
|
|
|
|
static void free_mailmap_entry(void *p, const char *s)
|
|
{
|
|
struct mailmap_entry *me = (struct mailmap_entry *)p;
|
|
debug_mm("mailmap: removing entries for <%s>, with %d sub-entries\n",
|
|
s, me->namemap.nr);
|
|
debug_mm("mailmap: - simple: '%s' <%s>\n",
|
|
debug_str(me->name), debug_str(me->email));
|
|
|
|
free(me->name);
|
|
free(me->email);
|
|
|
|
me->namemap.strdup_strings = 1;
|
|
string_list_clear_func(&me->namemap, free_mailmap_info);
|
|
}
|
|
|
|
/*
|
|
* On some systems (e.g. MinGW 4.0), string.h has _only_ inline
|
|
* definition of strcasecmp and no non-inline implementation is
|
|
* supplied anywhere, which is, eh, "unusual"; we cannot take an
|
|
* address of such a function to store it in namemap.cmp. This is
|
|
* here as a workaround---do not assign strcasecmp directly to
|
|
* namemap.cmp until we know no systems that matter have such an
|
|
* "unusual" string.h.
|
|
*/
|
|
static int namemap_cmp(const char *a, const char *b)
|
|
{
|
|
return strcasecmp(a, b);
|
|
}
|
|
|
|
static void add_mapping(struct string_list *map,
|
|
char *new_name, char *new_email,
|
|
char *old_name, char *old_email)
|
|
{
|
|
struct mailmap_entry *me;
|
|
struct string_list_item *item;
|
|
|
|
if (old_email == NULL) {
|
|
old_email = new_email;
|
|
new_email = NULL;
|
|
}
|
|
|
|
item = string_list_insert(map, old_email);
|
|
if (item->util) {
|
|
me = (struct mailmap_entry *)item->util;
|
|
} else {
|
|
me = xcalloc(1, sizeof(struct mailmap_entry));
|
|
me->namemap.strdup_strings = 1;
|
|
me->namemap.cmp = namemap_cmp;
|
|
item->util = me;
|
|
}
|
|
|
|
if (old_name == NULL) {
|
|
debug_mm("mailmap: adding (simple) entry for '%s'\n", old_email);
|
|
|
|
/* Replace current name and new email for simple entry */
|
|
if (new_name) {
|
|
free(me->name);
|
|
me->name = xstrdup(new_name);
|
|
}
|
|
if (new_email) {
|
|
free(me->email);
|
|
me->email = xstrdup(new_email);
|
|
}
|
|
} else {
|
|
struct mailmap_info *mi = xcalloc(1, sizeof(struct mailmap_info));
|
|
debug_mm("mailmap: adding (complex) entry for '%s'\n", old_email);
|
|
mi->name = xstrdup_or_null(new_name);
|
|
mi->email = xstrdup_or_null(new_email);
|
|
string_list_insert(&me->namemap, old_name)->util = mi;
|
|
}
|
|
|
|
debug_mm("mailmap: '%s' <%s> -> '%s' <%s>\n",
|
|
debug_str(old_name), old_email,
|
|
debug_str(new_name), debug_str(new_email));
|
|
}
|
|
|
|
static char *parse_name_and_email(char *buffer, char **name,
|
|
char **email, int allow_empty_email)
|
|
{
|
|
char *left, *right, *nstart, *nend;
|
|
*name = *email = NULL;
|
|
|
|
if ((left = strchr(buffer, '<')) == NULL)
|
|
return NULL;
|
|
if ((right = strchr(left+1, '>')) == NULL)
|
|
return NULL;
|
|
if (!allow_empty_email && (left+1 == right))
|
|
return NULL;
|
|
|
|
/* remove whitespace from beginning and end of name */
|
|
nstart = buffer;
|
|
while (isspace(*nstart) && nstart < left)
|
|
++nstart;
|
|
nend = left-1;
|
|
while (nend > nstart && isspace(*nend))
|
|
--nend;
|
|
|
|
*name = (nstart <= nend ? nstart : NULL);
|
|
*email = left+1;
|
|
*(nend+1) = '\0';
|
|
*right++ = '\0';
|
|
|
|
return (*right == '\0' ? NULL : right);
|
|
}
|
|
|
|
static void read_mailmap_line(struct string_list *map, char *buffer)
|
|
{
|
|
char *name1 = NULL, *email1 = NULL, *name2 = NULL, *email2 = NULL;
|
|
|
|
if (buffer[0] == '#')
|
|
return;
|
|
|
|
if ((name2 = parse_name_and_email(buffer, &name1, &email1, 0)) != NULL)
|
|
parse_name_and_email(name2, &name2, &email2, 1);
|
|
|
|
if (email1)
|
|
add_mapping(map, name1, email1, name2, email2);
|
|
}
|
|
|
|
static int read_mailmap_file(struct string_list *map, const char *filename)
|
|
{
|
|
char buffer[1024];
|
|
FILE *f;
|
|
|
|
if (!filename)
|
|
return 0;
|
|
|
|
f = fopen(filename, "r");
|
|
if (!f) {
|
|
if (errno == ENOENT)
|
|
return 0;
|
|
return error_errno("unable to open mailmap at %s", filename);
|
|
}
|
|
|
|
while (fgets(buffer, sizeof(buffer), f) != NULL)
|
|
read_mailmap_line(map, buffer);
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
|
|
static void read_mailmap_string(struct string_list *map, char *buf)
|
|
{
|
|
while (*buf) {
|
|
char *end = strchrnul(buf, '\n');
|
|
|
|
if (*end)
|
|
*end++ = '\0';
|
|
|
|
read_mailmap_line(map, buf);
|
|
buf = end;
|
|
}
|
|
}
|
|
|
|
static int read_mailmap_blob(struct string_list *map, const char *name)
|
|
{
|
|
struct object_id oid;
|
|
char *buf;
|
|
unsigned long size;
|
|
enum object_type type;
|
|
|
|
if (!name)
|
|
return 0;
|
|
if (get_oid(name, &oid) < 0)
|
|
return 0;
|
|
|
|
buf = read_object_file(&oid, &type, &size);
|
|
if (!buf)
|
|
return error("unable to read mailmap object at %s", name);
|
|
if (type != OBJ_BLOB)
|
|
return error("mailmap is not a blob: %s", name);
|
|
|
|
read_mailmap_string(map, buf);
|
|
|
|
free(buf);
|
|
return 0;
|
|
}
|
|
|
|
int read_mailmap(struct string_list *map)
|
|
{
|
|
int err = 0;
|
|
|
|
map->strdup_strings = 1;
|
|
map->cmp = namemap_cmp;
|
|
|
|
if (!git_mailmap_blob && is_bare_repository())
|
|
git_mailmap_blob = "HEAD:.mailmap";
|
|
|
|
if (!startup_info->have_repository || !is_bare_repository())
|
|
err |= read_mailmap_file(map, ".mailmap");
|
|
if (startup_info->have_repository)
|
|
err |= read_mailmap_blob(map, git_mailmap_blob);
|
|
err |= read_mailmap_file(map, git_mailmap_file);
|
|
return err;
|
|
}
|
|
|
|
void clear_mailmap(struct string_list *map)
|
|
{
|
|
debug_mm("mailmap: clearing %d entries...\n", map->nr);
|
|
map->strdup_strings = 1;
|
|
string_list_clear_func(map, free_mailmap_entry);
|
|
debug_mm("mailmap: cleared\n");
|
|
}
|
|
|
|
/*
|
|
* Look for an entry in map that match string[0:len]; string[len]
|
|
* does not have to be NUL (but it could be).
|
|
*/
|
|
static struct string_list_item *lookup_prefix(struct string_list *map,
|
|
const char *string, size_t len)
|
|
{
|
|
int i = string_list_find_insert_index(map, string, 1);
|
|
if (i < 0) {
|
|
/* exact match */
|
|
i = -1 - i;
|
|
if (!string[len])
|
|
return &map->items[i];
|
|
/*
|
|
* that map entry matches exactly to the string, including
|
|
* the cruft at the end beyond "len". That is not a match
|
|
* with string[0:len] that we are looking for.
|
|
*/
|
|
} else if (!string[len]) {
|
|
/*
|
|
* asked with the whole string, and got nothing. No
|
|
* matching entry can exist in the map.
|
|
*/
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* i is at the exact match to an overlong key, or location the
|
|
* overlong key would be inserted, which must come after the
|
|
* real location of the key if one exists.
|
|
*/
|
|
while (0 <= --i && i < map->nr) {
|
|
int cmp = strncasecmp(map->items[i].string, string, len);
|
|
if (cmp < 0)
|
|
/*
|
|
* "i" points at a key definitely below the prefix;
|
|
* the map does not have string[0:len] in it.
|
|
*/
|
|
break;
|
|
else if (!cmp && !map->items[i].string[len])
|
|
/* found it */
|
|
return &map->items[i];
|
|
/*
|
|
* otherwise, the string at "i" may be string[0:len]
|
|
* followed by a string that sorts later than string[len:];
|
|
* keep trying.
|
|
*/
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int map_user(struct string_list *map,
|
|
const char **email, size_t *emaillen,
|
|
const char **name, size_t *namelen)
|
|
{
|
|
struct string_list_item *item;
|
|
struct mailmap_entry *me;
|
|
|
|
debug_mm("map_user: map '%.*s' <%.*s>\n",
|
|
(int)*namelen, debug_str(*name),
|
|
(int)*emaillen, debug_str(*email));
|
|
|
|
item = lookup_prefix(map, *email, *emaillen);
|
|
if (item != NULL) {
|
|
me = (struct mailmap_entry *)item->util;
|
|
if (me->namemap.nr) {
|
|
/*
|
|
* The item has multiple items, so we'll look up on
|
|
* name too. If the name is not found, we choose the
|
|
* simple entry.
|
|
*/
|
|
struct string_list_item *subitem;
|
|
subitem = lookup_prefix(&me->namemap, *name, *namelen);
|
|
if (subitem)
|
|
item = subitem;
|
|
}
|
|
}
|
|
if (item != NULL) {
|
|
struct mailmap_info *mi = (struct mailmap_info *)item->util;
|
|
if (mi->name == NULL && mi->email == NULL) {
|
|
debug_mm("map_user: -- (no simple mapping)\n");
|
|
return 0;
|
|
}
|
|
if (mi->email) {
|
|
*email = mi->email;
|
|
*emaillen = strlen(*email);
|
|
}
|
|
if (mi->name) {
|
|
*name = mi->name;
|
|
*namelen = strlen(*name);
|
|
}
|
|
debug_mm("map_user: to '%.*s' <%.*s>\n",
|
|
(int)*namelen, debug_str(*name),
|
|
(int)*emaillen, debug_str(*email));
|
|
return 1;
|
|
}
|
|
debug_mm("map_user: --\n");
|
|
return 0;
|
|
}
|