rugged 1.3.2.3 → 1.4.2

data/vendor/libgit2/src/diff_driver.c

@@ -21,7 +21,7 @@ typedef enum {
 	DIFF_DRIVER_AUTO = 0,
 	DIFF_DRIVER_BINARY = 1,
 	DIFF_DRIVER_TEXT = 2,
-	DIFF_DRIVER_PATTERNLIST = 3,
+	DIFF_DRIVER_PATTERNLIST = 3
 } git_diff_driver_t;
 
 typedef struct {
@@ -51,11 +51,9 @@ struct git_diff_driver_registry {
 
 #define FORCE_DIFFABLE (GIT_DIFF_FORCE_TEXT | GIT_DIFF_FORCE_BINARY)
 
-static git_diff_driver global_drivers[3] = {
-	{ DIFF_DRIVER_AUTO,   0, 0, },
-	{ DIFF_DRIVER_BINARY, GIT_DIFF_FORCE_BINARY, 0 },
-	{ DIFF_DRIVER_TEXT,   GIT_DIFF_FORCE_TEXT, 0 },
-};
+static git_diff_driver diff_driver_auto =   { DIFF_DRIVER_AUTO,   0, 0 };
+static git_diff_driver diff_driver_binary = { DIFF_DRIVER_BINARY, GIT_DIFF_FORCE_BINARY, 0 };
+static git_diff_driver diff_driver_text =   { DIFF_DRIVER_TEXT,   GIT_DIFF_FORCE_TEXT, 0 };
 
 git_diff_driver_registry *git_diff_driver_registry_new(void)
 {
@@ -90,7 +88,7 @@ static int diff_driver_add_patterns(
 	int error = 0;
 	const char *scan, *end;
 	git_diff_driver_pattern *pat = NULL;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
 	for (scan = regex_str; scan; scan = end) {
 		/* get pattern to fill in */
@@ -105,10 +103,10 @@ static int diff_driver_add_patterns(
 		}
 
 		if ((end = strchr(scan, '\n')) != NULL) {
-			error = git_buf_set(&buf, scan, end - scan);
+			error = git_str_set(&buf, scan, end - scan);
 			end++;
 		} else {
-			error = git_buf_sets(&buf, scan);
+			error = git_str_sets(&buf, scan);
 		}
 		if (error < 0)
 			break;
@@ -122,7 +120,7 @@ static int diff_driver_add_patterns(
 
 	if (error && pat != NULL)
 		(void)git_array_pop(drv->fn_patterns); /* release last item */
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 
 	/* We want to ignore bad patterns, so return success regardless */
 	return 0;
@@ -237,7 +235,7 @@ static int git_diff_driver_load(
 	git_diff_driver *drv;
 	size_t namelen;
 	git_config *cfg = NULL;
-	git_buf name = GIT_BUF_INIT;
+	git_str name = GIT_STR_INIT;
 	git_config_entry *ce = NULL;
 	bool found_driver = false;
 
@@ -260,13 +258,13 @@ static int git_diff_driver_load(
 		goto done;
 	}
 
-	if ((error = git_buf_printf(&name, "diff.%s.binary", driver_name)) < 0)
+	if ((error = git_str_printf(&name, "diff.%s.binary", driver_name)) < 0)
 		goto done;
 
 	switch (git_config__get_bool_force(cfg, name.ptr, -1)) {
 	case true:
 		/* if diff.<driver>.binary is true, just return the binary driver */
-		*out = &global_drivers[DIFF_DRIVER_BINARY];
+		*out = &diff_driver_binary;
 		goto done;
 	case false:
 		/* if diff.<driver>.binary is false, force binary checks off */
@@ -281,8 +279,8 @@ static int git_diff_driver_load(
 
 	/* TODO: warn if diff.<name>.command or diff.<name>.textconv are set */
 
-	git_buf_truncate(&name, namelen + strlen("diff.."));
-	if ((error = git_buf_PUTS(&name, "xfuncname")) < 0)
+	git_str_truncate(&name, namelen + strlen("diff.."));
+	if ((error = git_str_PUTS(&name, "xfuncname")) < 0)
 		goto done;
 
 	if ((error = git_config_get_multivar_foreach(
@@ -292,8 +290,8 @@ static int git_diff_driver_load(
 		git_error_clear(); /* no diff.<driver>.xfuncname, so just continue */
 	}
 
-	git_buf_truncate(&name, namelen + strlen("diff.."));
-	if ((error = git_buf_PUTS(&name, "funcname")) < 0)
+	git_str_truncate(&name, namelen + strlen("diff.."));
+	if ((error = git_str_PUTS(&name, "funcname")) < 0)
 		goto done;
 
 	if ((error = git_config_get_multivar_foreach(
@@ -309,8 +307,8 @@ static int git_diff_driver_load(
 		found_driver = true;
 	}
 
-	git_buf_truncate(&name, namelen + strlen("diff.."));
-	if ((error = git_buf_PUTS(&name, "wordregex")) < 0)
+	git_str_truncate(&name, namelen + strlen("diff.."));
+	if ((error = git_str_PUTS(&name, "wordregex")) < 0)
 		goto done;
 
 	if ((error = git_config__lookup_entry(&ce, cfg, name.ptr, false)) < 0)
@@ -340,7 +338,7 @@ static int git_diff_driver_load(
 
 done:
 	git_config_entry_free(ce);
-	git_buf_dispose(&name);
+	git_str_dispose(&name);
 	git_config_free(cfg);
 
 	if (!*out) {
@@ -374,9 +372,9 @@ int git_diff_driver_lookup(
 	else if (GIT_ATTR_IS_UNSPECIFIED(values[0]))
 		/* just use the auto value */;
 	else if (GIT_ATTR_IS_FALSE(values[0]))
-		*out = &global_drivers[DIFF_DRIVER_BINARY];
+		*out = &diff_driver_binary;
 	else if (GIT_ATTR_IS_TRUE(values[0]))
-		*out = &global_drivers[DIFF_DRIVER_TEXT];
+		*out = &diff_driver_text;
 
 	/* otherwise look for driver information in config and build driver */
 	else if ((error = git_diff_driver_load(out, repo, values[0])) < 0) {
@@ -387,7 +385,7 @@ int git_diff_driver_lookup(
 	}
 
 	if (!*out)
-		*out = &global_drivers[DIFF_DRIVER_AUTO];
+		*out = &diff_driver_auto;
 
 	return error;
 }
@@ -420,11 +418,11 @@ void git_diff_driver_update_options(
 int git_diff_driver_content_is_binary(
 	git_diff_driver *driver, const char *content, size_t content_len)
 {
-	git_buf search = GIT_BUF_INIT;
+	git_str search = GIT_STR_INIT;
 
 	GIT_UNUSED(driver);
 
-	git_buf_attach_notowned(&search, content,
+	git_str_attach_notowned(&search, content,
 		min(content_len, GIT_FILTER_BYTES_TO_CHECK_NUL));
 
 	/* TODO: provide encoding / binary detection callbacks that can
@@ -432,15 +430,15 @@ int git_diff_driver_content_is_binary(
 	 * let's just use the simple NUL-byte detection that core git uses.
 	 */
 
-	/* previously was: if (git_buf_is_binary(&search)) */
-	if (git_buf_contains_nul(&search))
+	/* previously was: if (git_str_is_binary(&search)) */
+	if (git_str_contains_nul(&search))
 		return 1;
 
 	return 0;
 }
 
 static int diff_context_line__simple(
-	git_diff_driver *driver, git_buf *line)
+	git_diff_driver *driver, git_str *line)
 {
 	char firstch = line->ptr[0];
 	GIT_UNUSED(driver);
@@ -448,7 +446,7 @@ static int diff_context_line__simple(
 }
 
 static int diff_context_line__pattern_match(
-	git_diff_driver *driver, git_buf *line)
+	git_diff_driver *driver, git_str *line)
 {
 	size_t i, maxi = git_array_size(driver->fn_patterns);
 	git_regmatch pmatch[2];
@@ -462,9 +460,9 @@ static int diff_context_line__pattern_match(
 
 			/* use pmatch data to trim line data */
 			i = (pmatch[1].start >= 0) ? 1 : 0;
-			git_buf_consume(line, git_buf_cstr(line) + pmatch[i].start);
-			git_buf_truncate(line, pmatch[i].end - pmatch[i].start);
-			git_buf_rtrim(line);
+			git_str_consume(line, git_str_cstr(line) + pmatch[i].start);
+			git_str_truncate(line, pmatch[i].end - pmatch[i].start);
+			git_str_rtrim(line);
 
 			return true;
 		}
@@ -482,9 +480,9 @@ static long diff_context_find(
 {
 	git_diff_find_context_payload *ctxt = payload;
 
-	if (git_buf_set(&ctxt->line, line, (size_t)line_len) < 0)
+	if (git_str_set(&ctxt->line, line, (size_t)line_len) < 0)
 		return -1;
-	git_buf_rtrim(&ctxt->line);
+	git_str_rtrim(&ctxt->line);
 
 	if (!ctxt->line.size)
 		return -1;
@@ -511,14 +509,14 @@ void git_diff_find_context_init(
 		payload_out->driver = driver;
 		payload_out->match_line = (driver->type == DIFF_DRIVER_PATTERNLIST) ?
 			diff_context_line__pattern_match : diff_context_line__simple;
-		git_buf_init(&payload_out->line, 0);
+		git_str_init(&payload_out->line, 0);
 	}
 }
 
 void git_diff_find_context_clear(git_diff_find_context_payload *payload)
 {
 	if (payload) {
-		git_buf_dispose(&payload->line);
+		git_str_dispose(&payload->line);
 		payload->driver = NULL;
 	}
 }

data/vendor/libgit2/src/diff_driver.h

@@ -10,7 +10,7 @@
 #include "common.h"
 
 #include "attr_file.h"
-#include "buffer.h"
+#include "str.h"
 
 typedef struct git_diff_driver_registry git_diff_driver_registry;
 
@@ -34,12 +34,12 @@ typedef long (*git_diff_find_context_fn)(
 	const char *, long, char *, long, void *);
 
 typedef int (*git_diff_find_context_line)(
-	git_diff_driver *, git_buf *);
+	git_diff_driver *, git_str *);
 
 typedef struct {
 	git_diff_driver *driver;
 	git_diff_find_context_line match_line;
-	git_buf line;
+	git_str line;
 } git_diff_find_context_payload;
 
 void git_diff_find_context_init(

data/vendor/libgit2/src/diff_file.c

@@ -178,7 +178,7 @@ static int diff_file_content_commit_to_str(
 	git_diff_file_content *fc, bool check_status)
 {
 	char oid[GIT_OID_HEXSZ+1];
-	git_buf content = GIT_BUF_INIT;
+	git_str content = GIT_STR_INIT;
 	const char *status = "";
 
 	if (check_status) {
@@ -217,11 +217,11 @@ static int diff_file_content_commit_to_str(
 	}
 
 	git_oid_tostr(oid, sizeof(oid), &fc->file->id);
-	if (git_buf_printf(&content, "Subproject commit %s%s\n", oid, status) < 0)
+	if (git_str_printf(&content, "Subproject commit %s%s\n", oid, status) < 0)
 		return -1;
 
-	fc->map.len  = git_buf_len(&content);
-	fc->map.data = git_buf_detach(&content);
+	fc->map.len  = git_str_len(&content);
+	fc->map.data = git_str_detach(&content);
 	fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 
 	return 0;
@@ -270,24 +270,24 @@ static int diff_file_content_load_blob(
 }
 
 static int diff_file_content_load_workdir_symlink_fake(
-	git_diff_file_content *fc, git_buf *path)
+	git_diff_file_content *fc, git_str *path)
 {
-	git_buf target = GIT_BUF_INIT;
+	git_str target = GIT_STR_INIT;
 	int error;
 
 	if ((error = git_futils_readbuffer(&target, path->ptr)) < 0)
 		return error;
 
-	fc->map.len = git_buf_len(&target);
-	fc->map.data = git_buf_detach(&target);
+	fc->map.len = git_str_len(&target);
+	fc->map.data = git_str_detach(&target);
 	fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 
-	git_buf_dispose(&target);
+	git_str_dispose(&target);
 	return error;
 }
 
 static int diff_file_content_load_workdir_symlink(
-	git_diff_file_content *fc, git_buf *path)
+	git_diff_file_content *fc, git_str *path)
 {
 	ssize_t alloc_len, read_len;
 	int symlink_supported, error;
@@ -309,7 +309,7 @@ static int diff_file_content_load_workdir_symlink(
 
 	fc->flags |= GIT_DIFF_FLAG__FREE_DATA;
 
-	read_len = p_readlink(git_buf_cstr(path), fc->map.data, alloc_len);
+	read_len = p_readlink(git_str_cstr(path), fc->map.data, alloc_len);
 	if (read_len < 0) {
 		git_error_set(GIT_ERROR_OS, "failed to read symlink '%s'", fc->file->path);
 		return -1;
@@ -321,23 +321,32 @@ static int diff_file_content_load_workdir_symlink(
 
 static int diff_file_content_load_workdir_file(
 	git_diff_file_content *fc,
-	git_buf *path,
+	git_str *path,
 	git_diff_options *diff_opts)
 {
 	int error = 0;
 	git_filter_list *fl = NULL;
-	git_file fd = git_futils_open_ro(git_buf_cstr(path));
-	git_buf raw = GIT_BUF_INIT;
+	git_file fd = git_futils_open_ro(git_str_cstr(path));
+	git_str raw = GIT_STR_INIT;
+	git_object_size_t new_file_size = 0;
 
 	if (fd < 0)
 		return fd;
 
-	if (!fc->file->size)
-	    error = git_futils_filesize(&fc->file->size, fd);
+	error = git_futils_filesize(&new_file_size, fd);
 
-	if (error < 0 || !fc->file->size)
+	if (error < 0)
 		goto cleanup;
 
+	if (!(fc->file->flags & GIT_DIFF_FLAG_VALID_SIZE)) {
+		fc->file->size = new_file_size;
+		fc->file->flags |= GIT_DIFF_FLAG_VALID_SIZE;
+	} else if (fc->file->size != new_file_size) {
+		git_error_set(GIT_ERROR_FILESYSTEM, "file changed before we could read it");
+		error = -1;
+		goto cleanup;
+	}
+
 	if ((diff_opts->flags & GIT_DIFF_SHOW_BINARY) == 0 &&
 		diff_file_content_binary_by_size(fc))
 		goto cleanup;
@@ -360,7 +369,7 @@ static int diff_file_content_load_workdir_file(
 	}
 
 	if (!(error = git_futils_readbuffer_fd(&raw, fd, (size_t)fc->file->size))) {
-		git_buf out = GIT_BUF_INIT;
+		git_str out = GIT_STR_INIT;
 
 		error = git_filter_list__convert_buf(&out, fl, &raw);
 
@@ -383,7 +392,7 @@ static int diff_file_content_load_workdir(
 	git_diff_options *diff_opts)
 {
 	int error = 0;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 
 	if (fc->file->mode == GIT_FILEMODE_COMMIT)
 		return diff_file_content_commit_to_str(fc, true);
@@ -406,7 +415,7 @@ static int diff_file_content_load_workdir(
 		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 	}
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	return error;
 }
 

data/vendor/libgit2/src/diff_generate.c

@@ -117,6 +117,26 @@ static bool diff_pathspec_match(
 		matched_pathspec, NULL);
 }
 
+static void diff_delta__flag_known_size(git_diff_file *file)
+{
+	/*
+	 * If we don't know the ID, that can only come from the workdir
+	 * iterator, which means we *do* know the file size.  This is a
+	 * leaky abstraction, but alas.  Otherwise, we test against the
+	 * empty blob id.
+	 */
+	if (file->size ||
+	    !(file->flags & GIT_DIFF_FLAG_VALID_ID) ||
+	    git_oid_equal(&file->id, &git_oid__empty_blob_sha1))
+		file->flags |= GIT_DIFF_FLAG_VALID_SIZE;
+}
+
+static void diff_delta__flag_known_sizes(git_diff_delta *delta)
+{
+	diff_delta__flag_known_size(&delta->old_file);
+	diff_delta__flag_known_size(&delta->new_file);
+}
+
 static int diff_delta__from_one(
 	git_diff_generated *diff,
 	git_delta_t status,
@@ -182,6 +202,8 @@ static int diff_delta__from_one(
 	if (has_old || !git_oid_is_zero(&delta->new_file.id))
 		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
+	diff_delta__flag_known_sizes(delta);
+
 	return diff_insert_delta(diff, delta, matched_pathspec);
 }
 
@@ -244,6 +266,8 @@ static int diff_delta__from_two(
 			delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 	}
 
+	diff_delta__flag_known_sizes(delta);
+
 	return diff_insert_delta(diff, delta, matched_pathspec);
 }
 
@@ -586,7 +610,7 @@ int git_diff__oid_for_entry(
 	const git_oid *update_match)
 {
 	git_diff_generated *diff;
-	git_buf full_path = GIT_BUF_INIT;
+	git_str full_path = GIT_STR_INIT;
 	git_index_entry entry = *src;
 	git_filter_list *fl = NULL;
 	int error = 0;
@@ -605,8 +629,8 @@ int git_diff__oid_for_entry(
 		diff->base.perf.stat_calls++;
 
 		if (p_stat(full_path.ptr, &st) < 0) {
-			error = git_path_set_error(errno, entry.path, "stat");
-			git_buf_dispose(&full_path);
+			error = git_fs_path_set_error(errno, entry.path, "stat");
+			git_str_dispose(&full_path);
 			return error;
 		}
 
@@ -669,7 +693,7 @@ int git_diff__oid_for_entry(
 		}
  	}
 
-	git_buf_dispose(&full_path);
+	git_str_dispose(&full_path);
 	return error;
 }
 
@@ -1023,10 +1047,10 @@ static int handle_unmatched_new_item(
 
 		/* do not advance into directories that contain a .git file */
 		if (recurse_into_dir && !contains_oitem) {
-			git_buf *full = NULL;
+			git_str *full = NULL;
 			if (git_iterator_current_workdir_path(&full, info->new_iter) < 0)
 				return -1;
-			if (full && git_path_contains(full, DOT_GIT)) {
+			if (full && git_fs_path_contains(full, DOT_GIT)) {
 				/* TODO: warning if not a valid git repository */
 				recurse_into_dir = false;
 			}

data/vendor/libgit2/src/diff_generate.h

@@ -18,7 +18,7 @@ enum {
 	GIT_DIFFCAPS_IGNORE_STAT      = (1 << 1), /* use stat? */
 	GIT_DIFFCAPS_TRUST_MODE_BITS  = (1 << 2), /* use st_mode? */
 	GIT_DIFFCAPS_TRUST_CTIME      = (1 << 3), /* use st_ctime? */
-	GIT_DIFFCAPS_USE_DEV          = (1 << 4), /* use st_dev? */
+	GIT_DIFFCAPS_USE_DEV          = (1 << 4)  /* use st_dev? */
 };
 
 #define DIFF_FLAGS_KNOWN_BINARY (GIT_DIFF_FLAG_BINARY|GIT_DIFF_FLAG_NOT_BINARY)
@@ -36,7 +36,7 @@ enum {
 	GIT_DIFF_FLAG__TO_SPLIT   = (1 << 17), /* split entry during rename det. */
 	GIT_DIFF_FLAG__IS_RENAME_TARGET = (1 << 18),
 	GIT_DIFF_FLAG__IS_RENAME_SOURCE = (1 << 19),
-	GIT_DIFF_FLAG__HAS_SELF_SIMILARITY = (1 << 20),
+	GIT_DIFF_FLAG__HAS_SELF_SIMILARITY = (1 << 20)
 };
 
 #define GIT_DIFF_FLAG__CLEAR_INTERNAL(F) (F) = ((F) & 0x00FFFF)
@@ -119,8 +119,10 @@ GIT_INLINE(int) git_diff_file__resolve_zero_size(
 
 	git_odb_free(odb);
 
-	if (!error)
+	if (!error) {
 		file->size = (git_object_size_t)len;
+		file->flags |= GIT_DIFF_FLAG_VALID_SIZE;
+	}
 
 	return error;
 }