rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/libgit2/config_snapshot.c

@@ -8,12 +8,12 @@
 #include "config_backend.h"
 
 #include "config.h"
-#include "config_entries.h"
+#include "config_list.h"
 
 typedef struct {
 	git_config_backend parent;
 	git_mutex values_mutex;
-	git_config_entries *entries;
+	git_config_list *config_list;
 	git_config_backend *source;
 } config_snapshot_backend;
 
@@ -28,31 +28,27 @@ static int config_snapshot_iterator(
 	struct git_config_backend *backend)
 {
 	config_snapshot_backend *b = GIT_CONTAINER_OF(backend, config_snapshot_backend, parent);
-	git_config_entries *entries = NULL;
+	git_config_list *config_list = NULL;
 	int error;
 
-	if ((error = git_config_entries_dup(&entries, b->entries)) < 0 ||
-	    (error = git_config_entries_iterator_new(iter, entries)) < 0)
+	if ((error = git_config_list_dup(&config_list, b->config_list)) < 0 ||
+	    (error = git_config_list_iterator_new(iter, config_list)) < 0)
 		goto out;
 
 out:
-	/* Let iterator delete duplicated entries when it's done */
-	git_config_entries_free(entries);
+	/* Let iterator delete duplicated config_list when it's done */
+	git_config_list_free(config_list);
 	return error;
 }
 
-/* release the map containing the entry as an equivalent to freeing it */
-static void config_snapshot_entry_free(git_config_entry *entry)
-{
-	git_config_entries *entries = (git_config_entries *) entry->payload;
-	git_config_entries_free(entries);
-}
-
-static int config_snapshot_get(git_config_backend *cfg, const char *key, git_config_entry **out)
+static int config_snapshot_get(
+	git_config_backend *cfg,
+	const char *key,
+	git_config_backend_entry **out)
 {
 	config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent);
-	git_config_entries *entries = NULL;
-	git_config_entry *entry;
+	git_config_list *config_list = NULL;
+	git_config_list_entry *entry;
 	int error = 0;
 
 	if (git_mutex_lock(&b->values_mutex) < 0) {
@@ -60,19 +56,16 @@ static int config_snapshot_get(git_config_backend *cfg, const char *key, git_con
 	    return -1;
 	}
 
-	entries = b->entries;
-	git_config_entries_incref(entries);
+	config_list = b->config_list;
+	git_config_list_incref(config_list);
 	git_mutex_unlock(&b->values_mutex);
 
-	if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
-		git_config_entries_free(entries);
+	if ((error = (git_config_list_get(&entry, config_list, key))) < 0) {
+		git_config_list_free(config_list);
 		return error;
 	}
 
-	entry->free = config_snapshot_entry_free;
-	entry->payload = entries;
-	*out = entry;
-
+	*out = &entry->base;
 	return 0;
 }
 
@@ -135,7 +128,7 @@ static void config_snapshot_free(git_config_backend *_backend)
 	if (backend == NULL)
 		return;
 
-	git_config_entries_free(backend->entries);
+	git_config_list_free(backend->config_list);
 	git_mutex_free(&backend->values_mutex);
 	git__free(backend);
 }
@@ -143,7 +136,7 @@ static void config_snapshot_free(git_config_backend *_backend)
 static int config_snapshot_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
 {
 	config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent);
-	git_config_entries *entries = NULL;
+	git_config_list *config_list = NULL;
 	git_config_iterator *it = NULL;
 	git_config_entry *entry;
 	int error;
@@ -152,12 +145,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve
 	GIT_UNUSED(level);
 	GIT_UNUSED(repo);
 
-	if ((error = git_config_entries_new(&entries)) < 0 ||
+	if ((error = git_config_list_new(&config_list)) < 0 ||
 	    (error = b->source->iterator(&it, b->source)) < 0)
 		goto out;
 
 	while ((error = git_config_next(&entry, it)) == 0)
-		if ((error = git_config_entries_dup_entry(entries, entry)) < 0)
+		if ((error = git_config_list_dup_entry(config_list, entry)) < 0)
 			goto out;
 
 	if (error < 0) {
@@ -166,12 +159,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve
 		error = 0;
 	}
 
-	b->entries = entries;
+	b->config_list = config_list;
 
 out:
 	git_config_iterator_free(it);
 	if (error)
-		git_config_entries_free(entries);
+		git_config_list_free(config_list);
 	return error;
 }
 

data/vendor/libgit2/src/libgit2/describe.c

@@ -14,7 +14,6 @@
 #include "buf.h"
 #include "commit.h"
 #include "commit_list.h"
-#include "oidmap.h"
 #include "refs.h"
 #include "repository.h"
 #include "revwalk.h"
@@ -22,6 +21,7 @@
 #include "tag.h"
 #include "vector.h"
 #include "wildmatch.h"
+#include "hashmap_oid.h"
 
 /* Ported from https://github.com/git/git/blob/89dde7882f71f846ccd0359756d27bebc31108de/builtin/describe.c */
 
@@ -32,20 +32,22 @@ struct commit_name {
 	git_oid sha1;
 	char *path;
 
-	/* Khash workaround. They original key has to still be reachable */
+	/* The original key for the hashmap */
 	git_oid peeled;
 };
 
-static void *oidmap_value_bykey(git_oidmap *map, const git_oid *key)
-{
-	return git_oidmap_get(map, key);
-}
+GIT_HASHMAP_OID_SETUP(git_describe_oidmap, struct commit_name *);
 
 static struct commit_name *find_commit_name(
-	git_oidmap *names,
+	git_describe_oidmap *names,
 	const git_oid *peeled)
 {
-	return (struct commit_name *)(oidmap_value_bykey(names, peeled));
+	struct commit_name *result;
+
+	if (git_describe_oidmap_get(&result, names, peeled) == 0)
+		return result;
+
+	return NULL;
 }
 
 static int replace_name(
@@ -92,7 +94,7 @@ static int replace_name(
 
 static int add_to_known_names(
 	git_repository *repo,
-	git_oidmap *names,
+	git_describe_oidmap *names,
 	const char *path,
 	const git_oid *peeled,
 	unsigned int prio,
@@ -121,7 +123,7 @@ static int add_to_known_names(
 		e->path = git__strdup(path);
 		git_oid_cpy(&e->peeled, peeled);
 
-		if (!found && git_oidmap_set(names, &e->peeled, e) < 0)
+		if (!found && git_describe_oidmap_put(names, &e->peeled, e) < 0)
 			return -1;
 	}
 	else
@@ -174,7 +176,7 @@ struct get_name_data
 {
 	git_describe_options *opts;
 	git_repository *repo;
-	git_oidmap *names;
+	git_describe_oidmap names;
 	git_describe_result *result;
 };
 
@@ -240,7 +242,7 @@ static int get_name(const char *refname, void *payload)
 	else
 		prio = 0;
 
-	add_to_known_names(data->repo, data->names,
+	add_to_known_names(data->repo, &data->names,
 		all ? refname + strlen(GIT_REFS_DIR) : refname + strlen(GIT_REFS_TAGS_DIR),
 		&peeled, prio, &sha1);
 	return 0;
@@ -363,12 +365,15 @@ static int find_unique_abbrev_size(
 	size_t size = abbreviated_size;
 	git_odb *odb;
 	git_oid dummy;
+	size_t hexsize;
 	int error;
 
 	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
 		return error;
 
-	while (size < GIT_OID_SHA1_HEXSIZE) {
+	hexsize = git_oid_hexsize(repo->oid_type);
+
+	while (size < hexsize) {
 		if ((error = git_odb_exists_prefix(&dummy, odb, oid_in, size)) == 0) {
 			*out = (int) size;
 			return 0;
@@ -383,7 +388,7 @@ static int find_unique_abbrev_size(
 	}
 
 	/* If we didn't find any shorter prefix, we have to do the whole thing */
-	*out = GIT_OID_SHA1_HEXSIZE;
+	*out = (int)hexsize;
 
 	return 0;
 }
@@ -397,7 +402,7 @@ static int show_suffix(
 {
 	int error, size = 0;
 
-	char hex_oid[GIT_OID_SHA1_HEXSIZE];
+	char hex_oid[GIT_OID_MAX_HEXSIZE];
 
 	if ((error = find_unique_abbrev_size(&size, repo, id, abbrev_size)) < 0)
 		return error;
@@ -414,7 +419,7 @@ static int show_suffix(
 #define MAX_CANDIDATES_TAGS FLAG_BITS - 1
 
 static int describe_not_found(const git_oid *oid, const char *message_format) {
-	char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+	char oid_str[GIT_OID_MAX_HEXSIZE + 1];
 	git_oid_tostr(oid_str, sizeof(oid_str), oid);
 
 	git_error_set(GIT_ERROR_DESCRIBE, message_format, oid_str);
@@ -448,7 +453,7 @@ static int describe(
 
 	git_oid_cpy(&data->result->commit_id, git_commit_id(commit));
 
-	n = find_commit_name(data->names, git_commit_id(commit));
+	n = find_commit_name(&data->names, git_commit_id(commit));
 	if (n && (tags || all || n->prio == 2)) {
 		/*
 		 * Exact match to an existing ref.
@@ -489,7 +494,7 @@ static int describe(
 		git_commit_list_node *c = (git_commit_list_node *)git_pqueue_pop(&list);
 		seen_commits++;
 
-		n = find_commit_name(data->names, &c->oid);
+		n = find_commit_name(&data->names, &c->oid);
 
 		if (n) {
 			if (!tags && !all && n->prio < 2) {
@@ -525,7 +530,7 @@ static int describe(
 		if (annotated_cnt && (git_pqueue_size(&list) == 0)) {
 			/*
 			if (debug) {
-				char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+				char oid_str[GIT_OID_MAX_HEXSIZE + 1];
 				git_oid_tostr(oid_str, sizeof(oid_str), &c->oid);
 
 				fprintf(stderr, "finished search at %s\n", oid_str);
@@ -592,7 +597,7 @@ static int describe(
 			"head", "lightweight", "annotated",
 		};
 
-		char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+		char oid_str[GIT_OID_MAX_HEXSIZE + 1];
 
 		if (debug) {
 			for (cur_match = 0; cur_match < match_cnt; cur_match++) {
@@ -624,7 +629,7 @@ cleanup:
 			git__free(match);
 		}
 	}
-	git_vector_free(&all_matches);
+	git_vector_dispose(&all_matches);
 	git_pqueue_free(&list);
 	git_revwalk_free(walk);
 	return error;
@@ -650,11 +655,12 @@ int git_describe_commit(
 	git_object *committish,
 	git_describe_options *opts)
 {
-	struct get_name_data data;
+	struct get_name_data data = {0};
 	struct commit_name *name;
 	git_commit *commit;
-	int error = -1;
 	git_describe_options normalized;
+	git_hashmap_iter_t iter = GIT_HASHMAP_INIT;
+	int error = -1;
 
 	GIT_ASSERT_ARG(result);
 	GIT_ASSERT_ARG(committish);
@@ -674,9 +680,6 @@ int git_describe_commit(
 		"git_describe_options");
 	data.opts = &normalized;
 
-	if ((error = git_oidmap_new(&data.names)) < 0)
-		return error;
-
 	/** TODO: contains to be implemented */
 
 	if ((error = git_object_peel((git_object **)(&commit), committish, GIT_OBJECT_COMMIT)) < 0)
@@ -687,7 +690,7 @@ int git_describe_commit(
 			get_name, &data)) < 0)
 				goto cleanup;
 
-	if (git_oidmap_size(data.names) == 0 && !normalized.show_commit_oid_as_fallback) {
+	if (git_describe_oidmap_size(&data.names) == 0 && !normalized.show_commit_oid_as_fallback) {
 		git_error_set(GIT_ERROR_DESCRIBE, "cannot describe - "
 			"no reference found, cannot describe anything.");
 		error = -1;
@@ -700,13 +703,13 @@ int git_describe_commit(
 cleanup:
 	git_commit_free(commit);
 
-	git_oidmap_foreach_value(data.names, name, {
+	while (git_describe_oidmap_iterate(&iter, NULL, &name, &data.names) == 0) {
 		git_tag_free(name->tag);
 		git__free(name->path);
 		git__free(name);
-	});
+	}
 
-	git_oidmap_free(data.names);
+	git_describe_oidmap_dispose(&data.names);
 
 	if (error < 0)
 		git_describe_result_free(data.result);
@@ -816,7 +819,7 @@ static int git_describe__format(
 
 	/* If we didn't find *any* tags, we fall back to the commit's id */
 	if (result->fallback_to_id) {
-		char hex_oid[GIT_OID_SHA1_HEXSIZE + 1] = {0};
+		char hex_oid[GIT_OID_MAX_HEXSIZE + 1] = {0};
 		int size = 0;
 
 		if ((error = find_unique_abbrev_size(

data/vendor/libgit2/src/libgit2/diff.c

@@ -16,11 +16,13 @@
 #include "diff_generate.h"
 
 #include "git2/version.h"
-#include "git2/email.h"
+#include "git2/sys/email.h"
 
 struct patch_id_args {
+	git_diff *diff;
 	git_hash_ctx ctx;
 	git_oid result;
+	git_oid_t oid_type;
 	int first_file;
 };
 
@@ -280,17 +282,19 @@ int git_diff_find_options_init(
 	return 0;
 }
 
-static int flush_hunk(git_oid *result, git_hash_ctx *ctx)
+static int flush_hunk(git_oid *result, struct patch_id_args *args)
 {
+	git_hash_ctx *ctx = &args->ctx;
 	git_oid hash;
 	unsigned short carry = 0;
-	int error, i;
+	size_t i;
+	int error;
 
 	if ((error = git_hash_final(hash.id, ctx)) < 0 ||
 	    (error = git_hash_init(ctx)) < 0)
 		return error;
 
-	for (i = 0; i < GIT_OID_SHA1_SIZE; i++) {
+	for (i = 0; i < git_oid_size(args->oid_type); i++) {
 		carry += result->id[i] + hash.id[i];
 		result->id[i] = (unsigned char)carry;
 		carry >>= 8;
@@ -338,7 +342,7 @@ static int diff_patchid_print_callback_to_buf(
 
 	if (line->origin == GIT_DIFF_LINE_FILE_HDR &&
 	    !args->first_file &&
-	    (error = flush_hunk(&args->result, &args->ctx) < 0))
+	    (error = flush_hunk(&args->result, args) < 0))
 			goto out;
 
 	if ((error = git_hash_update(&args->ctx, buf.ptr, buf.size)) < 0)
@@ -362,14 +366,19 @@ int git_diff_patchid_options_init(git_diff_patchid_options *opts, unsigned int v
 int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opts)
 {
 	struct patch_id_args args;
+	git_hash_algorithm_t algorithm;
 	int error;
 
 	GIT_ERROR_CHECK_VERSION(
 		opts, GIT_DIFF_PATCHID_OPTIONS_VERSION, "git_diff_patchid_options");
 
+	algorithm = git_oid_algorithm(diff->opts.oid_type);
+
 	memset(&args, 0, sizeof(args));
+	args.diff = diff;
 	args.first_file = 1;
-	if ((error = git_hash_ctx_init(&args.ctx, GIT_HASH_ALGORITHM_SHA1)) < 0)
+	args.oid_type = diff->opts.oid_type;
+	if ((error = git_hash_ctx_init(&args.ctx, algorithm)) < 0)
 		goto out;
 
 	if ((error = git_diff_print(diff,
@@ -378,11 +387,11 @@ int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opt
 				    &args)) < 0)
 		goto out;
 
-	if ((error = (flush_hunk(&args.result, &args.ctx))) < 0)
+	if ((error = (flush_hunk(&args.result, &args))) < 0)
 		goto out;
 
 #ifdef GIT_EXPERIMENTAL_SHA256
-	args.result.type = GIT_OID_SHA1;
+	args.result.type = diff->opts.oid_type;
 #endif
 
 	git_oid_cpy(out, &args.result);

data/vendor/libgit2/src/libgit2/diff.h

@@ -30,15 +30,15 @@ typedef enum {
 } git_diff_origin_t;
 
 struct git_diff {
-	git_refcount     rc;
+	git_refcount      rc;
 	git_repository   *repo;
-	git_attr_session attrsession;
+	git_attr_session  attrsession;
 	git_diff_origin_t type;
-	git_diff_options opts;
-	git_vector       deltas;    /* vector of git_diff_delta */
+	git_diff_options  opts;
+	git_vector        deltas;    /* vector of git_diff_delta */
 	git_pool pool;
-	git_iterator_t old_src;
-	git_iterator_t new_src;
+	git_iterator_t    old_src;
+	git_iterator_t    new_src;
 	git_diff_perfdata perf;
 
 	int (*strcomp)(const char *, const char *);

data/vendor/libgit2/src/libgit2/diff_driver.c

@@ -11,11 +11,11 @@
 
 #include "common.h"
 #include "diff.h"
-#include "strmap.h"
 #include "map.h"
 #include "config.h"
 #include "regexp.h"
 #include "repository.h"
+#include "userdiff.h"
 
 typedef enum {
 	DIFF_DRIVER_AUTO = 0,
@@ -43,10 +43,10 @@ struct git_diff_driver {
 	char name[GIT_FLEX_ARRAY];
 };
 
-#include "userdiff.h"
+GIT_HASHMAP_STR_SETUP(git_diff_driver_map, git_diff_driver *);
 
 struct git_diff_driver_registry {
-	git_strmap *drivers;
+	git_diff_driver_map map;
 };
 
 #define FORCE_DIFFABLE (GIT_DIFF_FORCE_TEXT | GIT_DIFF_FORCE_BINARY)
@@ -57,28 +57,21 @@ static git_diff_driver diff_driver_text =   { DIFF_DRIVER_TEXT,   GIT_DIFF_FORCE
 
 git_diff_driver_registry *git_diff_driver_registry_new(void)
 {
-	git_diff_driver_registry *reg =
-		git__calloc(1, sizeof(git_diff_driver_registry));
-	if (!reg)
-		return NULL;
-
-	if (git_strmap_new(&reg->drivers) < 0) {
-		git_diff_driver_registry_free(reg);
-		return NULL;
-	}
-
-	return reg;
+	return git__calloc(1, sizeof(git_diff_driver_registry));
 }
 
 void git_diff_driver_registry_free(git_diff_driver_registry *reg)
 {
 	git_diff_driver *drv;
+	git_hashmap_iter_t iter = 0;
 
 	if (!reg)
 		return;
 
-	git_strmap_foreach_value(reg->drivers, drv, git_diff_driver_free(drv));
-	git_strmap_free(reg->drivers);
+	while (git_diff_driver_map_iterate(&iter, NULL, &drv, &reg->map) == 0)
+		git_diff_driver_free(drv);
+
+	git_diff_driver_map_dispose(&reg->map);
 	git__free(reg);
 }
 
@@ -215,7 +208,7 @@ static int git_diff_driver_builtin(
 	    (error = git_regexp_compile(&drv->word_pattern, ddef->words, ddef->flags)) < 0)
 		goto done;
 
-	if ((error = git_strmap_set(reg->drivers, drv->name, drv)) < 0)
+	if ((error = git_diff_driver_map_put(&reg->map, drv->name, drv)) < 0)
 		goto done;
 
 done:
@@ -242,7 +235,7 @@ static int git_diff_driver_load(
 	if ((reg = git_repository_driver_registry(repo)) == NULL)
 		return -1;
 
-	if ((drv = git_strmap_get(reg->drivers, driver_name)) != NULL) {
+	if (git_diff_driver_map_get(&drv, &reg->map, driver_name) == 0) {
 		*out = drv;
 		return 0;
 	}
@@ -331,7 +324,7 @@ static int git_diff_driver_load(
 		goto done;
 
 	/* store driver in registry */
-	if ((error = git_strmap_set(reg->drivers, drv->name, drv)) < 0)
+	if ((error = git_diff_driver_map_put(&reg->map, drv->name, drv)) < 0)
 		goto done;
 
 	*out = drv;

data/vendor/libgit2/src/libgit2/diff_driver.h

@@ -11,14 +11,14 @@
 
 #include "attr_file.h"
 #include "str.h"
+#include "hashmap.h"
 
+typedef struct git_diff_driver git_diff_driver;
 typedef struct git_diff_driver_registry git_diff_driver_registry;
 
 git_diff_driver_registry *git_diff_driver_registry_new(void);
 void git_diff_driver_registry_free(git_diff_driver_registry *);
 
-typedef struct git_diff_driver git_diff_driver;
-
 int git_diff_driver_lookup(git_diff_driver **, git_repository *,
 	git_attr_session *attrsession, const char *);
 void git_diff_driver_free(git_diff_driver *);

data/vendor/libgit2/src/libgit2/diff_file.c

@@ -112,7 +112,7 @@ int git_diff_file_content__init_from_diff(
 	case GIT_DELTA_DELETED:
 		has_data = use_old; break;
 	case GIT_DELTA_UNTRACKED:
-		has_data = !use_old &&
+		has_data = (use_old == (diff->opts.flags & GIT_DIFF_REVERSE)) &&
 			(diff->opts.flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) != 0;
 		break;
 	case GIT_DELTA_UNREADABLE:
@@ -144,7 +144,7 @@ int git_diff_file_content__init_from_src(
 
 	if (!src->blob && !src->buf) {
 		fc->flags |= GIT_DIFF_FLAG__NO_DATA;
-		git_oid_clear(&fc->file->id, GIT_OID_SHA1);
+		git_oid_clear(&fc->file->id, opts->oid_type);
 	} else {
 		fc->flags |= GIT_DIFF_FLAG__LOADED;
 		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
@@ -154,7 +154,7 @@ int git_diff_file_content__init_from_src(
 			git_blob_dup((git_blob **)&fc->blob, (git_blob *) src->blob);
 			fc->file->size = git_blob_rawsize(src->blob);
 			git_oid_cpy(&fc->file->id, git_blob_id(src->blob));
-			fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE;
+			fc->file->id_abbrev = (uint16_t)git_oid_hexsize(repo->oid_type);
 
 			fc->map.len  = (size_t)fc->file->size;
 			fc->map.data = (char *)git_blob_rawcontent(src->blob);
@@ -162,10 +162,10 @@ int git_diff_file_content__init_from_src(
 			fc->flags |= GIT_DIFF_FLAG__FREE_BLOB;
 		} else {
 			int error;
-			if ((error = git_odb__hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB, GIT_OID_SHA1)) < 0)
+			if ((error = git_odb__hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB, opts->oid_type)) < 0)
 				return error;
 			fc->file->size = src->buflen;
-			fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE;
+			fc->file->id_abbrev = (uint16_t)git_oid_hexsize(opts->oid_type);
 
 			fc->map.len  = src->buflen;
 			fc->map.data = (char *)src->buf;
@@ -178,7 +178,7 @@ int git_diff_file_content__init_from_src(
 static int diff_file_content_commit_to_str(
 	git_diff_file_content *fc, bool check_status)
 {
-	char oid[GIT_OID_SHA1_HEXSIZE+1];
+	char oid[GIT_OID_MAX_HEXSIZE+1];
 	git_str content = GIT_STR_INIT;
 	const char *status = "";
 
@@ -420,7 +420,7 @@ static int diff_file_content_load_workdir(
 	if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
 		error = git_odb__hash(
 			&fc->file->id, fc->map.data, fc->map.len,
-			GIT_OBJECT_BLOB, GIT_OID_SHA1);
+			GIT_OBJECT_BLOB, diff_opts->oid_type);
 		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 	}