Skip to content

G
git2
Commit 10672e3e by Russell Belfer
Options

Diff API cleanup 

This lays groundwork for separating formatting options from diff
creation options.  This groups the formatting flags separately
from the diff list creation flags and reorders the options.  This
also tweaks some APIs to further separate code that uses patches
from code that just looks at git_diffs.
parent 3ff1d123
Showing with 307 additions and 287 deletions
examples/diff.c
......@@ -114,12 +114,6 @@ static void usage(const char *message, const char *arg)
exit(1);
}
enum {
FORMAT_PATCH = 0,
FORMAT_COMPACT = 1,
FORMAT_RAW = 2
};
int main(int argc, char *argv[])
{
git_repository *repo = NULL;
......@@ -127,7 +121,8 @@ int main(int argc, char *argv[])
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
git_diff_find_options findopts = GIT_DIFF_FIND_OPTIONS_INIT;
git_diff *diff;
int i, color = -1, format = FORMAT_PATCH, cached = 0;
int i, color = -1, cached = 0;
git_diff_format_t format = GIT_DIFF_FORMAT_PATCH;
char *a, *treeish1 = NULL, *treeish2 = NULL;
const char *dir = ".";
......@@ -148,13 +143,15 @@ int main(int argc, char *argv[])
}
else if (!strcmp(a, "-p") || !strcmp(a, "-u") ||
!strcmp(a, "--patch"))
format = FORMAT_PATCH;
format = GIT_DIFF_FORMAT_PATCH;
else if (!strcmp(a, "--cached"))
cached = 1;
else if (!strcmp(a, "--name-only"))
format = GIT_DIFF_FORMAT_NAME_ONLY;
else if (!strcmp(a, "--name-status"))
format = FORMAT_COMPACT;
format = GIT_DIFF_FORMAT_NAME_STATUS;
else if (!strcmp(a, "--raw"))
format = FORMAT_RAW;
format = GIT_DIFF_FORMAT_RAW;
else if (!strcmp(a, "--color"))
color = 0;
else if (!strcmp(a, "--no-color"))
......@@ -238,17 +235,7 @@ int main(int argc, char *argv[])
if (color >= 0)
fputs(colors[0], stdout);
switch (format) {
case FORMAT_PATCH:
check(git_diff_print_patch(diff, printer, &color), "Displaying diff");
break;
case FORMAT_COMPACT:
check(git_diff_print_compact(diff, printer, &color), "Displaying diff");
break;
case FORMAT_RAW:
check(git_diff_print_raw(diff, printer, &color), "Displaying diff");
break;
}
check(git_diff_print(diff, format, printer, &color), "Displaying diff");
if (color >= 0)
fputs(colors[0], stdout);
......
examples/log.c
......@@ -388,7 +388,7 @@ int main(int argc, char *argv[])
check(git_diff_tree_to_tree(
&diff, git_commit_owner(commit), a, b, &diffopts),
"Diff commit with parent", NULL);
check(git_diff_print_patch(diff, print_diff, NULL),
check(git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, print_diff, NULL),
"Displaying diff", NULL);
git_diff_free(diff);
......
include/git2/patch.h
......@@ -47,17 +47,13 @@ typedef struct git_patch git_patch;
* It is okay to pass NULL for either of the output parameters; if you pass
* NULL for the `git_patch`, then the text diff will not be calculated.
*
* @param patch_out Output parameter for the delta patch object
* @param delta_out Output parameter for the delta object
* @param out Output parameter for the delta patch object
* @param diff Diff list object
* @param idx Index into diff list
* @return 0 on success, other value < 0 on error
*/
GIT_EXTERN(int) git_patch_from_diff(
git_patch **patch_out,
const git_diff_delta **delta_out,
git_diff *diff,
size_t idx);
git_patch **out, git_diff *diff, size_t idx);
/**
* Directly generate a patch from the difference between two blobs.
......@@ -112,20 +108,17 @@ GIT_EXTERN(int) git_patch_from_blob_and_buffer(
/**
* Free a git_patch object.
*/
GIT_EXTERN(void) git_patch_free(
git_patch *patch);
GIT_EXTERN(void) git_patch_free(git_patch *patch);
/**
* Get the delta associated with a patch
*/
GIT_EXTERN(const git_diff_delta *) git_patch_delta(
git_patch *patch);
GIT_EXTERN(const git_diff_delta *) git_patch_get_delta(git_patch *patch);
/**
* Get the number of hunks in a patch
*/
GIT_EXTERN(size_t) git_patch_num_hunks(
git_patch *patch);
GIT_EXTERN(size_t) git_patch_num_hunks(git_patch *patch);
/**
* Get line counts of each type in a patch.
......
src/diff.c
......@@ -81,7 +81,7 @@ static int diff_delta__from_one(
if (!git_pathspec__match(
&diff->pathspec, entry->path,
DIFF_FLAG_IS_SET(diff, GIT_DIFF_DISABLE_PATHSPEC_MATCH),
DIFF_FLAG_IS_SET(diff, GIT_DIFF_DELTAS_ARE_ICASE),
DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE),
&matched_pathspec, NULL))
return 0;
......@@ -368,14 +368,14 @@ static git_diff *diff_list_alloc(
* the ignore_case bit set */
if (!git_iterator_ignore_case(old_iter) &&
!git_iterator_ignore_case(new_iter)) {
diff->opts.flags &= ~GIT_DIFF_DELTAS_ARE_ICASE;
diff->opts.flags &= ~GIT_DIFF_IGNORE_CASE;
diff->strcomp = git__strcmp;
diff->strncomp = git__strncmp;
diff->pfxcomp = git__prefixcmp;
diff->entrycomp = git_index_entry__cmp;
} else {
diff->opts.flags |= GIT_DIFF_DELTAS_ARE_ICASE;
diff->opts.flags |= GIT_DIFF_IGNORE_CASE;
diff->strcomp = git__strcasecmp;
diff->strncomp = git__strncasecmp;
......@@ -399,9 +399,9 @@ static int diff_list_apply_options(
if (opts) {
/* copy user options (except case sensitivity info from iterators) */
bool icase = DIFF_FLAG_IS_SET(diff, GIT_DIFF_DELTAS_ARE_ICASE);
bool icase = DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE);
memcpy(&diff->opts, opts, sizeof(diff->opts));
DIFF_FLAG_SET(diff, GIT_DIFF_DELTAS_ARE_ICASE, icase);
DIFF_FLAG_SET(diff, GIT_DIFF_IGNORE_CASE, icase);
/* initialize pathspec from options */
if (git_pathspec__vinit(&diff->pathspec, &opts->pathspec, pool) < 0)
......@@ -413,7 +413,7 @@ static int diff_list_apply_options(
diff->opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE;
/* flag INCLUDE_UNTRACKED_CONTENT implies INCLUDE_UNTRACKED */
if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_UNTRACKED_CONTENT))
if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_SHOW_UNTRACKED_CONTENT))
diff->opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
/* load config values that affect diff behavior */
......@@ -674,7 +674,7 @@ static int maybe_modified(
if (!git_pathspec__match(
&diff->pathspec, oitem->path,
DIFF_FLAG_IS_SET(diff, GIT_DIFF_DISABLE_PATHSPEC_MATCH),
DIFF_FLAG_IS_SET(diff, GIT_DIFF_DELTAS_ARE_ICASE),
DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE),
&matched_pathspec, NULL))
return 0;
......@@ -910,7 +910,7 @@ static int handle_unmatched_new_item(
*/
if (!recurse_into_dir &&
delta_type == GIT_DELTA_UNTRACKED &&
DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_FAST_UNTRACKED_DIRS))
DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS))
{
git_diff_delta *last;
......@@ -1084,7 +1084,7 @@ int git_diff__from_iterators(
git_buf_init(&info.ignore_prefix, 0);
/* make iterators have matching icase behavior */
if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_DELTAS_ARE_ICASE)) {
if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE)) {
if ((error = git_iterator_set_ignore_case(old_iter, true)) < 0 ||
(error = git_iterator_set_ignore_case(new_iter, true)) < 0)
goto cleanup;
......@@ -1164,7 +1164,7 @@ int git_diff_tree_to_tree(
* currently case insensitive, unless the user explicitly asked
* for case insensitivity
*/
if (opts && (opts->flags & GIT_DIFF_DELTAS_ARE_ICASE) != 0)
if (opts && (opts->flags & GIT_DIFF_IGNORE_CASE) != 0)
iflag = GIT_ITERATOR_IGNORE_CASE;
DIFF_FROM_ITERATORS(
......@@ -1206,7 +1206,7 @@ int git_diff_tree_to_index(
if (!error) {
git_diff *d = *diff;
d->opts.flags |= GIT_DIFF_DELTAS_ARE_ICASE;
d->opts.flags |= GIT_DIFF_IGNORE_CASE;
d->strcomp = git__strcasecmp;
d->strncomp = git__strncasecmp;
d->pfxcomp = git__prefixcmp_icase;
......@@ -1242,7 +1242,6 @@ int git_diff_index_to_workdir(
return error;
}
int git_diff_tree_to_workdir(
git_diff **diff,
git_repository *repo,
......@@ -1262,16 +1261,43 @@ int git_diff_tree_to_workdir(
return error;
}
size_t git_diff_num_deltas(git_diff *diff)
int git_diff_tree_to_workdir_with_index(
git_diff **diff,
git_repository *repo,
git_tree *old_tree,
const git_diff_options *opts)
{
int error = 0;
git_diff *d1 = NULL, *d2 = NULL;
assert(diff && repo);
if (!(error = git_diff_tree_to_index(&d1, repo, old_tree, NULL, opts)) &&
!(error = git_diff_index_to_workdir(&d2, repo, NULL, opts)))
error = git_diff_merge(d1, d2);
git_diff_free(d2);
if (error) {
git_diff_free(d1);
d1 = NULL;
}
*diff = d1;
return error;
}
size_t git_diff_num_deltas(const git_diff *diff)
{
assert(diff);
return (size_t)diff->deltas.length;
return diff->deltas.length;
}
size_t git_diff_num_deltas_of_type(git_diff *diff, git_delta_t type)
size_t git_diff_num_deltas_of_type(const git_diff *diff, git_delta_t type)
{
size_t i, count = 0;
git_diff_delta *delta;
const git_diff_delta *delta;
assert(diff);
......@@ -1282,9 +1308,15 @@ size_t git_diff_num_deltas_of_type(git_diff *diff, git_delta_t type)
return count;
}
const git_diff_delta *git_diff_get_delta(const git_diff *diff, size_t idx)
{
assert(diff);
return git_vector_get(&diff->deltas, idx);
}
int git_diff_is_sorted_icase(const git_diff *diff)
{
return (diff->opts.flags & GIT_DIFF_DELTAS_ARE_ICASE) != 0;
return (diff->opts.flags & GIT_DIFF_IGNORE_CASE) != 0;
}
int git_diff__paired_foreach(
......@@ -1318,10 +1350,10 @@ int git_diff__paired_foreach(
* always sort by the old name in the i2w list.
*/
h2i_icase = head2idx != NULL &&
(head2idx->opts.flags & GIT_DIFF_DELTAS_ARE_ICASE) != 0;
(head2idx->opts.flags & GIT_DIFF_IGNORE_CASE) != 0;
i2w_icase = idx2wd != NULL &&
(idx2wd->opts.flags & GIT_DIFF_DELTAS_ARE_ICASE) != 0;
(idx2wd->opts.flags & GIT_DIFF_IGNORE_CASE) != 0;
icase_mismatch =
(head2idx != NULL && idx2wd != NULL && h2i_icase != i2w_icase);
......
src/diff_file.c
......@@ -110,7 +110,7 @@ int git_diff_file_content__init_from_diff(
has_data = use_old; break;
case GIT_DELTA_UNTRACKED:
has_data = !use_old &&
(diff->opts.flags & GIT_DIFF_INCLUDE_UNTRACKED_CONTENT) != 0;
(diff->opts.flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) != 0;
break;
case GIT_DELTA_MODIFIED:
case GIT_DELTA_COPIED:
......
src/diff_patch.c
......@@ -17,7 +17,9 @@ typedef struct diff_patch_line diff_patch_line;
struct diff_patch_line {
const char *ptr;
size_t len;
size_t lines, oldno, newno;
size_t lines;
size_t oldno;
size_t newno;
char origin;
};
......@@ -109,9 +111,7 @@ static int diff_patch_init_from_diff(
}
static int diff_patch_alloc_from_diff(
git_patch **out,
git_diff *diff,
size_t delta_index)
git_patch **out, git_diff *diff, size_t delta_index)
{
int error;
git_patch *patch = git__calloc(1, sizeof(git_patch));
......@@ -605,10 +605,7 @@ int git_patch_from_blob_and_buffer(
}
int git_patch_from_diff(
git_patch **patch_ptr,
const git_diff_delta **delta_ptr,
git_diff *diff,
size_t idx)
git_patch **patch_ptr, git_diff *diff, size_t idx)
{
int error = 0;
git_xdiff_output xo;
......@@ -616,7 +613,6 @@ int git_patch_from_diff(
git_patch *patch = NULL;
if (patch_ptr) *patch_ptr = NULL;
if (delta_ptr) *delta_ptr = NULL;
if (diff_required(diff, "git_patch_from_diff") < 0)
return -1;
......@@ -627,9 +623,6 @@ int git_patch_from_diff(
return GIT_ENOTFOUND;
}
if (delta_ptr)
*delta_ptr = delta;
if (git_diff_delta__should_skip(&diff->opts, delta))
return 0;
......@@ -671,7 +664,7 @@ void git_patch_free(git_patch *patch)
GIT_REFCOUNT_DEC(patch, diff_patch_free);
}
const git_diff_delta *git_patch_delta(git_patch *patch)
const git_diff_delta *git_patch_get_delta(git_patch *patch)
{
assert(patch);
return patch->delta;
......
src/diff_print.c
......@@ -11,22 +11,34 @@
typedef struct {
git_diff *diff;
git_diff_format_t format;
git_diff_line_cb print_cb;
void *payload;
git_buf *buf;
uint32_t flags;
int oid_strlen;
} diff_print_info;
static int diff_print_info_init(
diff_print_info *pi,
git_buf *out, git_diff *diff, git_diff_line_cb cb, void *payload)
git_buf *out,
git_diff *diff,
git_diff_format_t format,
git_diff_line_cb cb,
void *payload)
{
pi->diff = diff;
pi->format = format;
pi->print_cb = cb;
pi->payload = payload;
pi->buf = out;
if (!diff || !diff->repo)
if (diff)
pi->flags = diff->opts.flags;
if (diff && diff->opts.oid_abbrev != 0)
pi->oid_strlen = diff->opts.oid_abbrev;
else if (!diff || !diff->repo)
pi->oid_strlen = GIT_ABBREV_DEFAULT;
else if (git_repository__cvar(
&pi->oid_strlen, diff->repo, GIT_CVAR_ABBREV) < 0)
......@@ -77,7 +89,32 @@ static int callback_error(void)
return GIT_EUSER;
}
static int diff_print_one_compact(
static int diff_print_one_name_only(
const git_diff_delta *delta, float progress, void *data)
{
diff_print_info *pi = data;
git_buf *out = pi->buf;
GIT_UNUSED(progress);
if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 &&
delta->status == GIT_DELTA_UNMODIFIED)
return 0;
git_buf_clear(out);
if (git_buf_puts(out, delta->new_file.path) < 0 ||
git_buf_putc(out, '\n'))
return -1;
if (pi->print_cb(delta, NULL, GIT_DIFF_LINE_FILE_HDR,
git_buf_cstr(out), git_buf_len(out), pi->payload))
return callback_error();
return 0;
}
static int diff_print_one_name_status(
const git_diff_delta *delta, float progress, void *data)
{
diff_print_info *pi = data;
......@@ -88,7 +125,7 @@ static int diff_print_one_compact(
GIT_UNUSED(progress);
if (code == ' ')
if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 && code == ' ')
return 0;
old_suffix = diff_pick_suffix(delta->old_file.mode);
......@@ -119,24 +156,6 @@ static int diff_print_one_compact(
return 0;
}
/* print a git_diff to a print callback in compact format */
int git_diff_print_compact(
git_diff *diff,
git_diff_line_cb print_cb,
void *payload)
{
int error;
git_buf buf = GIT_BUF_INIT;
diff_print_info pi;
if (!(error = diff_print_info_init(&pi, &buf, diff, print_cb, payload)))
error = git_diff_foreach(diff, diff_print_one_compact, NULL, NULL, &pi);
git_buf_free(&buf);
return error;
}
static int diff_print_one_raw(
const git_diff_delta *delta, float progress, void *data)
{
......@@ -147,7 +166,7 @@ static int diff_print_one_raw(
GIT_UNUSED(progress);
if (code == ' ')
if ((pi->flags & GIT_DIFF_SHOW_UNMODIFIED) == 0 && code == ' ')
return 0;
git_buf_clear(out);
......@@ -180,24 +199,6 @@ static int diff_print_one_raw(
return 0;
}
/* print a git_diff to a print callback in raw output format */
int git_diff_print_raw(
git_diff *diff,
git_diff_line_cb print_cb,
void *payload)
{
int error;
git_buf buf = GIT_BUF_INIT;
diff_print_info pi;
if (!(error = diff_print_info_init(&pi, &buf, diff, print_cb, payload)))
error = git_diff_foreach(diff, diff_print_one_raw, NULL, NULL, &pi);
git_buf_free(&buf);
return error;
}
static int diff_print_oid_range(
git_buf *out, const git_diff_delta *delta, int oid_strlen)
{
......@@ -287,7 +288,6 @@ static int diff_print_patch_file(
pi->diff ? pi->diff->opts.old_prefix : DIFF_OLD_PREFIX_DEFAULT;
const char *newpfx =
pi->diff ? pi->diff->opts.new_prefix : DIFF_NEW_PREFIX_DEFAULT;
uint32_t opts_flags = pi->diff ? pi->diff->opts.flags : GIT_DIFF_NORMAL;
GIT_UNUSED(progress);
......@@ -295,7 +295,7 @@ static int diff_print_patch_file(
delta->status == GIT_DELTA_UNMODIFIED ||
delta->status == GIT_DELTA_IGNORED ||
(delta->status == GIT_DELTA_UNTRACKED &&
(opts_flags & GIT_DIFF_INCLUDE_UNTRACKED_CONTENT) == 0))
(pi->flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) == 0))
return 0;
if (git_diff_delta__format_file_header(
......@@ -379,20 +379,47 @@ static int diff_print_patch_line(
return 0;
}
/* print a git_diff to an output callback in patch format */
int git_diff_print_patch(
/* print a git_diff to an output callback */
int git_diff_print(
git_diff *diff,
git_diff_format_t format,
git_diff_line_cb print_cb,
void *payload)
{
int error;
git_buf buf = GIT_BUF_INIT;
diff_print_info pi;
git_diff_file_cb print_file = NULL;
git_diff_hunk_cb print_hunk = NULL;
git_diff_line_cb print_line = NULL;
switch (format) {
case GIT_DIFF_FORMAT_PATCH:
print_file = diff_print_patch_file;
print_hunk = diff_print_patch_hunk;
print_line = diff_print_patch_line;
break;
case GIT_DIFF_FORMAT_PATCH_HEADER:
print_file = diff_print_patch_file;
break;
case GIT_DIFF_FORMAT_RAW:
print_file = diff_print_one_raw;
break;
case GIT_DIFF_FORMAT_NAME_ONLY:
print_file = diff_print_one_name_only;
break;
case GIT_DIFF_FORMAT_NAME_STATUS:
print_file = diff_print_one_name_status;
break;
default:
giterr_set(GITERR_INVALID, "Unknown diff output format (%d)", format);
return -1;
}
if (!(error = diff_print_info_init(&pi, &buf, diff, print_cb, payload)))
if (!(error = diff_print_info_init(
&pi, &buf, diff, format, print_cb, payload)))
error = git_diff_foreach(
diff, diff_print_patch_file, diff_print_patch_hunk,
diff_print_patch_line, &pi);
diff, print_file, print_hunk, print_line, &pi);
git_buf_free(&buf);
......@@ -412,7 +439,8 @@ int git_patch_print(
assert(patch && print_cb);
if (!(error = diff_print_info_init(
&pi, &temp, git_patch__diff(patch), print_cb, payload)))
&pi, &temp, git_patch__diff(patch),
GIT_DIFF_FORMAT_PATCH, print_cb, payload)))
error = git_patch__invoke_callbacks(
patch, diff_print_patch_file, diff_print_patch_hunk,
diff_print_patch_line, &pi);
......
src/diff_tform.c
......@@ -117,15 +117,15 @@ int git_diff_merge(
git_pool_init(&onto_pool, 1, 0) < 0)
return -1;
if ((onto->opts.flags & GIT_DIFF_DELTAS_ARE_ICASE) != 0 ||
(from->opts.flags & GIT_DIFF_DELTAS_ARE_ICASE) != 0)
if ((onto->opts.flags & GIT_DIFF_IGNORE_CASE) != 0 ||
(from->opts.flags & GIT_DIFF_IGNORE_CASE) != 0)
{
ignore_case = true;
/* This function currently only supports merging diff lists that
* are sorted identically. */
assert((onto->opts.flags & GIT_DIFF_DELTAS_ARE_ICASE) != 0 &&
(from->opts.flags & GIT_DIFF_DELTAS_ARE_ICASE) != 0);
assert((onto->opts.flags & GIT_DIFF_IGNORE_CASE) != 0 &&
(from->opts.flags & GIT_DIFF_IGNORE_CASE) != 0);
}
for (i = 0, j = 0; i < onto->deltas.length || j < from->deltas.length; ) {
......@@ -232,7 +232,7 @@ int git_diff_find_similar__calc_similarity(
static int normalize_find_opts(
git_diff *diff,
git_diff_find_options *opts,
git_diff_find_options *given)
const git_diff_find_options *given)
{
git_config *cfg = NULL;
......@@ -760,7 +760,7 @@ typedef struct {
int git_diff_find_similar(
git_diff *diff,
git_diff_find_options *given_opts)
const git_diff_find_options *given_opts)
{
size_t s, t;
int error = 0, similarity;
......
src/diff_xdiff.c
......@@ -59,7 +59,7 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
{
git_xdiff_info *info = priv;
git_patch *patch = info->patch;
const git_diff_delta *delta = git_patch_delta(patch);
const git_diff_delta *delta = git_patch_get_delta(patch);
git_diff_output *output = &info->xo->output;
if (len == 1) {
......@@ -145,7 +145,7 @@ static int git_xdiff(git_diff_output *output, git_patch *patch)
void git_xdiff_init(git_xdiff_output *xo, const git_diff_options *opts)
{
uint32_t flags = opts ? opts->flags : GIT_DIFF_NORMAL;
uint32_t flags = opts ? opts->flags : 0;
xo->output.diff_cb = git_xdiff;
......
src/reset.c
......@@ -26,8 +26,7 @@ int git_reset_default(
git_tree *tree = NULL;
git_diff *diff = NULL;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
size_t i;
git_diff_delta *delta;
size_t i, max_i;
git_index_entry entry;
int error;
git_index *index = NULL;
......@@ -58,7 +57,9 @@ int git_reset_default(
&diff, repo, tree, index, &opts)) < 0)
goto cleanup;
git_vector_foreach(&diff->deltas, i, delta) {
for (i = 0, max_i = git_diff_num_deltas(diff); i < max_i; ++i) {
const git_diff_delta *delta = git_diff_get_delta(diff, i);
if ((error = git_index_conflict_remove(index, delta->old_file.path)) < 0)
goto cleanup;
......
src/stash.c
......@@ -153,65 +153,61 @@ cleanup:
return error;
}
struct cb_data {
git_index *index;
int error;
struct stash_update_rules {
bool include_changed;
bool include_untracked;
bool include_ignored;
};
static int update_index_cb(
const git_diff_delta *delta,
float progress,
void *payload)
static int stash_update_index_from_diff(
git_index *index,
const git_diff *diff,
struct stash_update_rules *data)
{
struct cb_data *data = (struct cb_data *)payload;
const char *add_path = NULL;
GIT_UNUSED(progress);
switch (delta->status) {
case GIT_DELTA_IGNORED:
if (data->include_ignored)
add_path = delta->new_file.path;
break;
case GIT_DELTA_UNTRACKED:
if (data->include_untracked)
add_path = delta->new_file.path;
break;
case GIT_DELTA_ADDED:
case GIT_DELTA_MODIFIED:
if (data->include_changed)
add_path = delta->new_file.path;
break;
case GIT_DELTA_DELETED:
if (!data->include_changed)
int error = 0;
size_t d, max_d = git_diff_num_deltas(diff);
for (d = 0; !error && d < max_d; ++d) {
const char *add_path = NULL;
const git_diff_delta *delta = git_diff_get_delta(diff, d);
switch (delta->status) {
case GIT_DELTA_IGNORED:
if (data->include_ignored)
add_path = delta->new_file.path;
break;
case GIT_DELTA_UNTRACKED:
if (data->include_untracked)
add_path = delta->new_file.path;
break;
case GIT_DELTA_ADDED:
case GIT_DELTA_MODIFIED:
if (data->include_changed)
add_path = delta->new_file.path;
break;
case GIT_DELTA_DELETED:
if (data->include_changed &&
!git_index_find(NULL, index, delta->old_file.path))
error = git_index_remove(index, delta->old_file.path, 0);
break;
if (git_index_find(NULL, data->index, delta->old_file.path) == 0)
data->error = git_index_remove(
data->index, delta->old_file.path, 0);
break;
default:
/* Unimplemented */
giterr_set(
GITERR_INVALID,
"Cannot update index. Unimplemented status (%d)",
delta->status);
data->error = -1;
break;
}
if (add_path != NULL)
data->error = git_index_add_bypath(data->index, add_path);
default:
/* Unimplemented */
giterr_set(
GITERR_INVALID,
"Cannot update index. Unimplemented status (%d)",
delta->status);
return -1;
}
if (add_path != NULL)
error = git_index_add_bypath(index, add_path);
}
return data->error;
return error;
}
static int build_untracked_tree(
......@@ -223,13 +219,11 @@ static int build_untracked_tree(
git_tree *i_tree = NULL;
git_diff *diff = NULL;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
struct cb_data data = {0};
struct stash_update_rules data = {0};
int error;
git_index_clear(index);
data.index = index;
if (flags & GIT_STASH_INCLUDE_UNTRACKED) {
opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED |
GIT_DIFF_RECURSE_UNTRACKED_DIRS;
......@@ -248,13 +242,8 @@ static int build_untracked_tree(
&diff, git_index_owner(index), i_tree, &opts)) < 0)
goto cleanup;
if ((error = git_diff_foreach(
diff, update_index_cb, NULL, NULL, &data)) < 0)
{
if (error == GIT_EUSER)
error = data.error;
if ((error = stash_update_index_from_diff(index, diff, &data)) < 0)
goto cleanup;
}
error = build_tree_from_index(tree_out, index);
......@@ -311,9 +300,9 @@ static int build_workdir_tree(
{
git_repository *repo = git_index_owner(index);
git_tree *b_tree = NULL;
git_diff *diff = NULL, *diff2 = NULL;
git_diff *diff = NULL;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
struct cb_data data = {0};
struct stash_update_rules data = {0};
int error;
opts.flags = GIT_DIFF_IGNORE_SUBMODULES;
......@@ -321,33 +310,19 @@ static int build_workdir_tree(
if ((error = git_commit_tree(&b_tree, b_commit)) < 0)
goto cleanup;
if ((error = git_diff_tree_to_index(&diff, repo, b_tree, NULL, &opts)) < 0)
if ((error = git_diff_tree_to_workdir_with_index(
&diff, repo, b_tree, &opts)) < 0)
goto cleanup;
if ((error = git_diff_index_to_workdir(&diff2, repo, NULL, &opts)) < 0)
goto cleanup;
if ((error = git_diff_merge(diff, diff2)) < 0)
goto cleanup;
data.index = index;
data.include_changed = true;
if ((error = git_diff_foreach(
diff, update_index_cb, NULL, NULL, &data)) < 0)
{
if (error == GIT_EUSER)
error = data.error;
if ((error = stash_update_index_from_diff(index, diff, &data)) < 0)
goto cleanup;
}
if ((error = build_tree_from_index(tree_out, index)) < 0)
goto cleanup;
error = build_tree_from_index(tree_out, index);
cleanup:
git_diff_free(diff);
git_diff_free(diff2);
git_tree_free(b_tree);
return error;
......
tests-clar/diff/blob.c
......@@ -165,7 +165,7 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.oid));
......@@ -188,7 +188,7 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
cl_assert(git_oid_equal(git_blob_id(b), &delta->old_file.oid));
......@@ -211,7 +211,7 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.oid));
......@@ -231,7 +231,7 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
cl_assert(git_oid_equal(git_blob_id(c), &delta->old_file.oid));
......@@ -326,7 +326,7 @@ void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_DELETED, delta->status);
cl_assert(git_oid_equal(git_blob_id(d), &delta->old_file.oid));
......@@ -351,7 +351,7 @@ void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_ADDED, delta->status);
cl_assert(git_oid_iszero(&delta->old_file.oid));
......@@ -376,7 +376,7 @@ void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_DELETED, delta->status);
cl_assert((delta->flags & GIT_DIFF_FLAG_BINARY) != 0);
......@@ -389,7 +389,7 @@ void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_ADDED, delta->status);
cl_assert((delta->flags & GIT_DIFF_FLAG_BINARY) != 0);
......@@ -443,7 +443,7 @@ void test_diff_blob__can_compare_identical_blobs_with_patch(void)
cl_git_pass(git_patch_from_blobs(&p, d, NULL, d, NULL, &opts));
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, delta->status);
cl_assert_equal_sz(delta->old_file.size, git_blob_rawsize(d));
......@@ -457,7 +457,7 @@ void test_diff_blob__can_compare_identical_blobs_with_patch(void)
cl_git_pass(git_patch_from_blobs(&p, NULL, NULL, NULL, NULL, &opts));
cl_assert(p != NULL);
delta = git_patch_delta(p);
delta = git_patch_get_delta(p);
cl_assert(delta != NULL);
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, delta->status);
cl_assert_equal_sz(0, delta->old_file.size);
......@@ -470,7 +470,7 @@ void test_diff_blob__can_compare_identical_blobs_with_patch(void)
cl_git_pass(git_patch_from_blobs(&p, alien, NULL, alien, NULL, &opts));
cl_assert(p != NULL);
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, git_patch_delta(p)->status);
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, git_patch_get_delta(p)->status);
cl_assert_equal_i(0, (int)git_patch_num_hunks(p));
git_patch_free(p);
}
......@@ -709,7 +709,7 @@ void test_diff_blob__can_compare_blob_to_buffer_with_patch(void)
&p, a, NULL, b_content, strlen(b_content), NULL, &opts));
cl_assert(p != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, git_patch_delta(p)->status);
cl_assert_equal_i(GIT_DELTA_MODIFIED, git_patch_get_delta(p)->status);
cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
cl_assert_equal_i(6, git_patch_num_lines_in_hunk(p, 0));
......@@ -725,7 +725,7 @@ void test_diff_blob__can_compare_blob_to_buffer_with_patch(void)
cl_git_pass(git_patch_from_blob_and_buffer(
&p, a, NULL, a_content, strlen(a_content), NULL, &opts));
cl_assert(p != NULL);
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, git_patch_delta(p)->status);
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, git_patch_get_delta(p)->status);
cl_assert_equal_i(0, (int)git_patch_num_hunks(p));
git_patch_free(p);
......@@ -733,7 +733,7 @@ void test_diff_blob__can_compare_blob_to_buffer_with_patch(void)
cl_git_pass(git_patch_from_blob_and_buffer(
&p, NULL, NULL, a_content, strlen(a_content), NULL, &opts));
cl_assert(p != NULL);
cl_assert_equal_i(GIT_DELTA_ADDED, git_patch_delta(p)->status);
cl_assert_equal_i(GIT_DELTA_ADDED, git_patch_get_delta(p)->status);
cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
cl_assert_equal_i(1, git_patch_num_lines_in_hunk(p, 0));
git_patch_free(p);
......@@ -742,7 +742,7 @@ void test_diff_blob__can_compare_blob_to_buffer_with_patch(void)
cl_git_pass(git_patch_from_blob_and_buffer(
&p, a, NULL, NULL, 0, NULL, &opts));
cl_assert(p != NULL);
cl_assert_equal_i(GIT_DELTA_DELETED, git_patch_delta(p)->status);
cl_assert_equal_i(GIT_DELTA_DELETED, git_patch_get_delta(p)->status);
cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
cl_assert_equal_i(1, git_patch_num_lines_in_hunk(p, 0));
git_patch_free(p);
......@@ -753,7 +753,7 @@ void test_diff_blob__can_compare_blob_to_buffer_with_patch(void)
cl_git_pass(git_patch_from_blob_and_buffer(
&p, a, NULL, NULL, 0, NULL, &opts));
cl_assert(p != NULL);
cl_assert_equal_i(GIT_DELTA_ADDED, git_patch_delta(p)->status);
cl_assert_equal_i(GIT_DELTA_ADDED, git_patch_get_delta(p)->status);
cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
cl_assert_equal_i(1, git_patch_num_lines_in_hunk(p, 0));
git_patch_free(p);
......
tests-clar/diff/diff_helpers.c
......@@ -162,8 +162,8 @@ int diff_foreach_via_iterator(
const git_diff_delta *delta;
size_t h, num_h;
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, d));
cl_assert(delta);
cl_git_pass(git_patch_from_diff(&patch, diff, d));
cl_assert((delta = git_patch_get_delta(patch)) != NULL);
/* call file_cb for this file */
if (file_cb != NULL && file_cb(delta, (float)d / num_d, data) != 0) {
......@@ -245,10 +245,12 @@ static int diff_print_cb(
void diff_print(FILE *fp, git_diff *diff)
{
cl_git_pass(git_diff_print_patch(diff, diff_print_cb, fp ? fp : stderr));
cl_git_pass(git_diff_print(
diff, GIT_DIFF_FORMAT_PATCH, diff_print_cb, fp ? fp : stderr));
}
void diff_print_raw(FILE *fp, git_diff *diff)
{
cl_git_pass(git_diff_print_raw(diff, diff_print_cb, fp ? fp : stderr));
cl_git_pass(git_diff_print(
diff, GIT_DIFF_FORMAT_RAW, diff_print_cb, fp ? fp : stderr));
}
tests-clar/diff/diffiter.c
......@@ -20,10 +20,12 @@ void test_diff_diffiter__create(void)
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
const git_diff_delta *delta;
cl_git_pass(git_patch_from_diff(NULL, &delta, diff, d));
const git_diff_delta *delta = git_diff_get_delta(diff, d);
cl_assert(delta != NULL);
}
cl_assert(!git_diff_get_delta(diff, num_d));
git_diff_free(diff);
}
......@@ -39,8 +41,7 @@ void test_diff_diffiter__iterate_files_1(void)
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
const git_diff_delta *delta;
cl_git_pass(git_patch_from_diff(NULL, &delta, diff, d));
const git_diff_delta *delta = git_diff_get_delta(diff, d);
cl_assert(delta != NULL);
diff_file_cb(delta, (float)d / (float)num_d, &exp);
......@@ -63,8 +64,7 @@ void test_diff_diffiter__iterate_files_2(void)
cl_assert_equal_i(8, (int)num_d);
for (d = 0; d < num_d; ++d) {
const git_diff_delta *delta;
cl_git_pass(git_patch_from_diff(NULL, &delta, diff, d));
const git_diff_delta *delta = git_diff_get_delta(diff, d);
cl_assert(delta != NULL);
count++;
}
......@@ -91,12 +91,9 @@ void test_diff_diffiter__iterate_files_and_hunks(void)
for (d = 0; d < num_d; ++d) {
git_patch *patch;
const git_diff_delta *delta;
size_t h, num_h;
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, d));
cl_assert(delta);
cl_git_pass(git_patch_from_diff(&patch, diff, d));
cl_assert(patch);
file_count++;
......@@ -145,9 +142,10 @@ void test_diff_diffiter__max_size_threshold(void)
git_patch *patch;
const git_diff_delta *delta;
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, d));
cl_assert(delta);
cl_git_pass(git_patch_from_diff(&patch, diff, d));
cl_assert(patch);
delta = git_patch_get_delta(patch);
cl_assert(delta);
file_count++;
hunk_count += (int)git_patch_num_hunks(patch);
......@@ -180,7 +178,8 @@ void test_diff_diffiter__max_size_threshold(void)
git_patch *patch;
const git_diff_delta *delta;
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, d));
cl_git_pass(git_patch_from_diff(&patch, diff, d));
delta = git_patch_get_delta(patch);
file_count++;
hunk_count += (int)git_patch_num_hunks(patch);
......@@ -221,11 +220,10 @@ void test_diff_diffiter__iterate_all(void)
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
git_patch *patch;
const git_diff_delta *delta;
size_t h, num_h;
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, d));
cl_assert(patch && delta);
cl_git_pass(git_patch_from_diff(&patch, diff, d));
cl_assert(patch);
exp.files++;
num_h = git_patch_num_hunks(patch);
......@@ -312,7 +310,7 @@ void test_diff_diffiter__iterate_randomly_while_saving_state(void)
patches[p] = NULL;
/* cache new patch */
cl_git_pass(git_patch_from_diff(&patches[p], NULL, diff, d));
cl_git_pass(git_patch_from_diff(&patches[p], diff, d));
cl_assert(patches[p] != NULL);
/* process old patch if non-NULL */
......@@ -428,7 +426,7 @@ void test_diff_diffiter__iterate_and_generate_patch_text(void)
git_patch *patch;
char *text;
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, d));
cl_git_pass(git_patch_from_diff(&patch, diff, d));
cl_assert(patch != NULL);
cl_git_pass(git_patch_to_str(&text, patch));
......
tests-clar/diff/drivers.c
......@@ -44,7 +44,7 @@ void test_diff_drivers__patterns(void)
cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, one, NULL));
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
cl_assert_equal_s(expected0, text);
......@@ -59,7 +59,7 @@ void test_diff_drivers__patterns(void)
cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, one, NULL));
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
cl_assert_equal_s(expected1, text);
......@@ -74,7 +74,7 @@ void test_diff_drivers__patterns(void)
cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, one, NULL));
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
cl_assert_equal_s(expected0, text);
......@@ -91,7 +91,7 @@ void test_diff_drivers__patterns(void)
cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, one, NULL));
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
cl_assert_equal_s(expected1, text);
......@@ -112,7 +112,7 @@ void test_diff_drivers__patterns(void)
cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, one, NULL));
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
cl_assert_equal_s(expected2, text);
......@@ -144,7 +144,7 @@ void test_diff_drivers__long_lines(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
cl_assert_equal_sz(1, git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&actual, patch));
/* if chmod not supported, overwrite mode bits since anything is possible */
......
tests-clar/diff/patch.c
......@@ -95,7 +95,8 @@ void test_diff_patch__can_properly_display_the_removal_of_a_file(void)
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, one, another, NULL));
cl_git_pass(git_diff_print_patch(diff, check_removal_cb, NULL));
cl_git_pass(git_diff_print(
diff, GIT_DIFF_FORMAT_PATCH, check_removal_cb, NULL));
git_diff_free(diff);
......@@ -122,7 +123,7 @@ void test_diff_patch__to_string(void)
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
......@@ -167,7 +168,7 @@ void test_diff_patch__config_options(void)
cl_git_pass(git_diff_tree_to_index(&diff, g_repo, one, NULL, &opts));
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
cl_assert_equal_s(expected1, text);
......@@ -178,7 +179,7 @@ void test_diff_patch__config_options(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
cl_assert_equal_s(expected2, text);
......@@ -192,7 +193,7 @@ void test_diff_patch__config_options(void)
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
cl_assert_equal_s(expected3, text);
......@@ -206,7 +207,7 @@ void test_diff_patch__config_options(void)
cl_git_pass(git_diff_tree_to_index(&diff, g_repo, one, NULL, &opts));
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_str(&text, patch));
cl_assert_equal_s(expected4, text);
......@@ -253,7 +254,8 @@ void test_diff_patch__hunks_have_correct_line_numbers(void)
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_assert((delta = git_patch_get_delta(patch)) != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, (int)delta->status);
cl_assert_equal_i(2, (int)git_patch_num_hunks(patch));
......@@ -346,7 +348,8 @@ void test_diff_patch__hunks_have_correct_line_numbers(void)
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_assert((delta = git_patch_get_delta(patch)) != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, (int)delta->status);
cl_assert_equal_i(1, (int)git_patch_num_hunks(patch));
......@@ -427,7 +430,8 @@ static void check_single_patch_stats(
cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_assert((delta = git_patch_get_delta(patch)) != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, (int)delta->status);
cl_assert_equal_i((int)hunks, (int)git_patch_num_hunks(patch));
......
tests-clar/diff/rename.c
......@@ -584,7 +584,8 @@ void test_diff_rename__patch(void)
cl_assert_equal_i(4, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, 0));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_assert((delta = git_patch_get_delta(patch)) != NULL);
cl_assert_equal_i(GIT_DELTA_COPIED, (int)delta->status);
cl_git_pass(git_patch_to_str(&text, patch));
......@@ -593,13 +594,13 @@ void test_diff_rename__patch(void)
git_patch_free(patch);
cl_git_pass(git_patch_from_diff(NULL, &delta, diff, 1));
cl_assert((delta = git_diff_get_delta(diff, 1)) != NULL);
cl_assert_equal_i(GIT_DELTA_UNMODIFIED, (int)delta->status);
cl_git_pass(git_patch_from_diff(NULL, &delta, diff, 2));
cl_assert((delta = git_diff_get_delta(diff, 2)) != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, (int)delta->status);
cl_git_pass(git_patch_from_diff(NULL, &delta, diff, 3));
cl_assert((delta = git_diff_get_delta(diff, 3)) != NULL);
cl_assert_equal_i(GIT_DELTA_MODIFIED, (int)delta->status);
git_diff_free(diff);
......
tests-clar/diff/submodules.c
......@@ -22,7 +22,8 @@ static void check_diff_patches_at_line(
char *patch_text;
for (d = 0; d < num_d; ++d, git_patch_free(patch)) {
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, d));
cl_git_pass(git_patch_from_diff(&patch, diff, d));
cl_assert((delta = git_patch_get_delta(patch)) != NULL);
if (delta->status == GIT_DELTA_UNMODIFIED) {
cl_assert_at_line(expected[d] == NULL, file, line);
......@@ -123,7 +124,7 @@ void test_diff_submodules__dirty_submodule_2(void)
cl_git_pass(git_submodule_reload_all(g_repo));
opts.flags = GIT_DIFF_INCLUDE_UNTRACKED |
GIT_DIFF_INCLUDE_UNTRACKED_CONTENT |
GIT_DIFF_SHOW_UNTRACKED_CONTENT |
GIT_DIFF_RECURSE_UNTRACKED_DIRS |
GIT_DIFF_DISABLE_PATHSPEC_MATCH;
opts.old_prefix = "a"; opts.new_prefix = "b";
......
tests-clar/diff/tree.c
......@@ -90,6 +90,9 @@ void test_diff_tree__0(void)
git_tree_free(c);
}
#define DIFF_OPTS(FLAGS, CTXT) \
{GIT_DIFF_OPTIONS_VERSION, (FLAGS), 0, {NULL,0}, NULL, NULL, (CTXT), 1}
void test_diff_tree__options(void)
{
/* grabbed a couple of commit oids from the history of the attr repo */
......@@ -102,16 +105,16 @@ void test_diff_tree__options(void)
int test_ab_or_cd[] = { 0, 0, 0, 0, 1, 1, 1, 1, 1 };
git_diff_options test_options[] = {
/* a vs b tests */
{ 1, GIT_DIFF_NORMAL, 1, 1, NULL, NULL, {0} },
{ 1, GIT_DIFF_NORMAL, 3, 1, NULL, NULL, {0} },
{ 1, GIT_DIFF_REVERSE, 2, 1, NULL, NULL, {0} },
{ 1, GIT_DIFF_FORCE_TEXT, 2, 1, NULL, NULL, {0} },
DIFF_OPTS(GIT_DIFF_NORMAL, 1),
DIFF_OPTS(GIT_DIFF_NORMAL, 3),
DIFF_OPTS(GIT_DIFF_REVERSE, 2),
DIFF_OPTS(GIT_DIFF_FORCE_TEXT, 2),
/* c vs d tests */
{ 1, GIT_DIFF_NORMAL, 3, 1, NULL, NULL, {0} },
{ 1, GIT_DIFF_IGNORE_WHITESPACE, 3, 1, NULL, NULL, {0} },
{ 1, GIT_DIFF_IGNORE_WHITESPACE_CHANGE, 3, 1, NULL, NULL, {0} },
{ 1, GIT_DIFF_IGNORE_WHITESPACE_EOL, 3, 1, NULL, NULL, {0} },
{ 1, GIT_DIFF_IGNORE_WHITESPACE | GIT_DIFF_REVERSE, 1, 1, NULL, NULL, {0} },
DIFF_OPTS(GIT_DIFF_NORMAL, 3),
DIFF_OPTS(GIT_DIFF_IGNORE_WHITESPACE, 3),
DIFF_OPTS(GIT_DIFF_IGNORE_WHITESPACE_CHANGE, 3),
DIFF_OPTS(GIT_DIFF_IGNORE_WHITESPACE_EOL, 3),
DIFF_OPTS(GIT_DIFF_IGNORE_WHITESPACE | GIT_DIFF_REVERSE, 1),
};
/* to generate these values:
......@@ -255,7 +258,6 @@ void test_diff_tree__larger_hunks(void)
const char *a_commit = "d70d245ed97ed2aa596dd1af6536e4bfdb047b69";
const char *b_commit = "7a9e0b02e63179929fed24f0a3e0f19168114d10";
size_t d, num_d, h, num_h, l, num_l, header_len, line_len;
const git_diff_delta *delta;
git_patch *patch;
const git_diff_hunk *range;
const char *header, *line;
......@@ -273,8 +275,8 @@ void test_diff_tree__larger_hunks(void)
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
cl_git_pass(git_patch_from_diff(&patch, &delta, diff, d));
cl_assert(patch && delta);
cl_git_pass(git_patch_from_diff(&patch, diff, d));
cl_assert(patch);
num_h = git_patch_num_hunks(patch);
for (h = 0; h < num_h; h++) {
......@@ -297,7 +299,7 @@ void test_diff_tree__larger_hunks(void)
git_patch_free(patch);
}
cl_git_fail(git_patch_from_diff(&patch, &delta, diff, num_d));
cl_git_fail(git_patch_from_diff(&patch, diff, num_d));
cl_assert_equal_i(2, (int)num_d);
}
......
tests-clar/diff/workdir.c
......@@ -707,7 +707,7 @@ void test_diff_workdir__larger_hunks(void)
cl_assert_equal_i(2, (int)num_d);
for (d = 0; d < num_d; ++d) {
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, d));
cl_git_pass(git_patch_from_diff(&patch, diff, d));
cl_assert(patch);
num_h = git_patch_num_hunks(patch);
......@@ -769,7 +769,7 @@ void test_diff_workdir__submodules(void)
GIT_DIFF_INCLUDE_UNTRACKED |
GIT_DIFF_INCLUDE_IGNORED |
GIT_DIFF_RECURSE_UNTRACKED_DIRS |
GIT_DIFF_INCLUDE_UNTRACKED_CONTENT;
GIT_DIFF_SHOW_UNTRACKED_CONTENT;
cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, a, &opts));
......@@ -912,7 +912,7 @@ void test_diff_workdir__can_diff_empty_file(void)
cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, tree, &opts));
cl_assert_equal_i(3, (int)git_diff_num_deltas(diff));
/* diffs are: .gitattributes, README.txt, sub/sub/.gitattributes */
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 1));
cl_git_pass(git_patch_from_diff(&patch, diff, 1));
git_patch_free(patch);
git_diff_free(diff);
......@@ -923,7 +923,7 @@ void test_diff_workdir__can_diff_empty_file(void)
cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, tree, &opts));
cl_assert_equal_i(3, (int)git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(&patch, NULL, diff, 1));
cl_git_pass(git_patch_from_diff(&patch, diff, 1));
git_patch_free(patch);
git_diff_free(diff);
......@@ -1170,7 +1170,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
/* quick version avoids directory scan */
opts.flags = opts.flags | GIT_DIFF_FAST_UNTRACKED_DIRS;
opts.flags = opts.flags | GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS;
memset(&exp, 0, sizeof(exp));
exp.names = files1;
......@@ -1190,7 +1190,7 @@ void test_diff_workdir__untracked_directory_scenarios(void)
/* directory with nested non-ignored content */
opts.flags = opts.flags & ~GIT_DIFF_FAST_UNTRACKED_DIRS;
opts.flags = opts.flags & ~GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS;
cl_git_mkfile("status/subdir/directory/more/notignored",
"not ignored deep under untracked\n");
......@@ -1271,14 +1271,17 @@ void test_diff_workdir__untracked_with_bom(void)
"\xFF\xFE\x31\x00\x32\x00\x33\x00\x34\x00", 10, O_WRONLY|O_CREAT, 0664);
opts.flags =
GIT_DIFF_INCLUDE_UNTRACKED | GIT_DIFF_INCLUDE_UNTRACKED_CONTENT;
GIT_DIFF_INCLUDE_UNTRACKED | GIT_DIFF_SHOW_UNTRACKED_CONTENT;
cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
cl_assert_equal_i(1, git_diff_num_deltas(diff));
cl_git_pass(git_patch_from_diff(NULL, &delta, diff, 0));
cl_assert((delta = git_diff_get_delta(diff, 0)) != NULL);
cl_assert_equal_i(GIT_DELTA_UNTRACKED, delta->status);
cl_assert((delta->flags & GIT_DIFF_FLAG_BINARY) != 0);
/* not known at this point
* cl_assert((delta->flags & GIT_DIFF_FLAG_BINARY) != 0);
*/
git_diff_free(diff);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment