PyObject *
Diff_patch__get__(Diff *self)
{
git_patch* patch;
git_buf buf = {NULL};
int err = GIT_ERROR;
size_t i, len, num;
PyObject *py_patch = NULL;
num = git_diff_num_deltas(self->list);
if (num == 0)
Py_RETURN_NONE;
for (i = 0, len = 1; i < num ; ++i) {
err = git_patch_from_diff(&patch, self->list, i);
if (err < 0)
goto cleanup;
/* This appends to the current buf, so we can simply keep passing it */
err = git_patch_to_buf(&buf, patch);
if (err < 0)
goto cleanup;
git_patch_free(patch);
}
py_patch = to_unicode(buf.ptr, NULL, NULL);
git_buf_free(&buf);
cleanup:
git_buf_free(&buf);
return (err < 0) ? Error_set(err) : py_patch;
}
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;
git_patch *patch;
const git_diff_hunk *hunk;
const git_diff_line *line;
g_repo = cl_git_sandbox_init("diff");
cl_assert((a = resolve_commit_oid_to_tree(g_repo, a_commit)) != NULL);
cl_assert((b = resolve_commit_oid_to_tree(g_repo, b_commit)) != NULL);
opts.context_lines = 1;
opts.interhunk_lines = 0;
cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts));
num_d = git_diff_num_deltas(diff);
for (d = 0; d < num_d; ++d) {
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++) {
cl_git_pass(git_patch_get_hunk(&hunk, &num_l, patch, h));
for (l = 0; l < num_l; ++l) {
cl_git_pass(git_patch_get_line_in_hunk(&line, patch, h, l));
cl_assert(line);
}
cl_git_fail(git_patch_get_line_in_hunk(&line, patch, h, num_l));
}
cl_git_fail(git_patch_get_hunk(&hunk, &num_l, patch, num_h));
git_patch_free(patch);
}
cl_git_fail(git_patch_from_diff(&patch, diff, num_d));
cl_assert_equal_i(2, (int)num_d);
}
void test_diff_parse__get_patch_from_diff(void)
{
git_repository *repo;
git_diff *computed, *parsed;
git_tree *a, *b;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
git_buf computed_buf = GIT_BUF_INIT;
git_patch *patch_computed, *patch_parsed;
repo = cl_git_sandbox_init("diff");
opts.flags = GIT_DIFF_SHOW_BINARY;
cl_assert((a = resolve_commit_oid_to_tree(repo,
"d70d245ed97ed2aa596dd1af6536e4bfdb047b69")) != NULL);
cl_assert((b = resolve_commit_oid_to_tree(repo,
"7a9e0b02e63179929fed24f0a3e0f19168114d10")) != NULL);
cl_git_pass(git_diff_tree_to_tree(&computed, repo, a, b, &opts));
cl_git_pass(git_diff_to_buf(&computed_buf,
computed, GIT_DIFF_FORMAT_PATCH));
cl_git_pass(git_patch_from_diff(&patch_computed, computed, 0));
cl_git_pass(git_diff_from_buffer(&parsed,
computed_buf.ptr, computed_buf.size));
cl_git_pass(git_patch_from_diff(&patch_parsed, parsed, 0));
cl_assert_equal_i(
git_patch_num_hunks(patch_computed),
git_patch_num_hunks(patch_parsed));
git_patch_free(patch_computed);
git_patch_free(patch_parsed);
git_tree_free(a);
git_tree_free(b);
git_diff_free(computed);
git_diff_free(parsed);
git_buf_free(&computed_buf);
cl_git_sandbox_cleanup();
}
PyObject*
diff_get_patch_byindex(git_diff *diff, size_t idx)
{
git_patch *patch = NULL;
int err;
err = git_patch_from_diff(&patch, diff, idx);
if (err < 0)
return Error_set(err);
return (PyObject*) wrap_patch(patch);
}
void test_patch(
const char *one,
const char *two,
const git_diff_options *opts,
const char *expected)
{
git_oid id_one, id_two;
git_index *index = NULL;
git_commit *commit_one, *commit_two = NULL;
git_tree *tree_one, *tree_two;
git_diff *diff;
git_patch *patch;
git_buf actual = GIT_BUF_INIT;
cl_git_pass(git_oid_fromstr(&id_one, one));
cl_git_pass(git_commit_lookup(&commit_one, repo, &id_one));
cl_git_pass(git_commit_tree(&tree_one, commit_one));
if (two) {
cl_git_pass(git_oid_fromstr(&id_two, two));
cl_git_pass(git_commit_lookup(&commit_two, repo, &id_two));
cl_git_pass(git_commit_tree(&tree_two, commit_two));
} else {
cl_git_pass(git_repository_index(&index, repo));
cl_git_pass(git_index_write_tree(&id_two, index));
cl_git_pass(git_tree_lookup(&tree_two, repo, &id_two));
}
cl_git_pass(git_diff_tree_to_tree(&diff, repo, tree_one, tree_two, opts));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_buf(&actual, patch));
cl_assert_equal_s(expected, actual.ptr);
git_buf_clear(&actual);
cl_git_pass(git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, git_diff_print_callback__to_buf, &actual));
cl_assert_equal_s(expected, actual.ptr);
git_buf_dispose(&actual);
git_patch_free(patch);
git_diff_free(diff);
git_tree_free(tree_one);
git_tree_free(tree_two);
git_commit_free(commit_one);
git_commit_free(commit_two);
git_index_free(index);
}
void test_diff_binary__index_to_workdir(void)
{
git_index *index;
git_diff *diff;
git_patch *patch;
git_buf actual = GIT_BUF_INIT;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
const char *expected =
"diff --git a/untimely.txt b/untimely.txt\n" \
"index 9a69d960ae94b060f56c2a8702545e2bb1abb935..1111d4f11f4b35bf6759e0fb714fe09731ef0840 100644\n" \
"GIT binary patch\n" \
"delta 32\n" \
"nc%1vf+QYWt3zLL@hC)e3Vu?a>QDRl4f_G*?PG(-ZA}<#J$+QbW\n" \
"\n" \
"delta 7\n" \
"Oc%18D`@*{63ljhg(E~C7\n" \
"\n";
opts.flags = GIT_DIFF_SHOW_BINARY | GIT_DIFF_FORCE_BINARY;
opts.id_abbrev = GIT_OID_HEXSZ;
repo = cl_git_sandbox_init("renames");
cl_git_pass(git_repository_index(&index, repo));
cl_git_append2file("renames/untimely.txt", "Oh that crazy Kipling!\r\n");
cl_git_pass(git_diff_index_to_workdir(&diff, repo, index, &opts));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_to_buf(&actual, patch));
cl_assert_equal_s(expected, actual.ptr);
cl_git_pass(git_index_add_bypath(index, "untimely.txt"));
cl_git_pass(git_index_write(index));
test_patch(
"19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13",
NULL,
&opts,
expected);
git_buf_dispose(&actual);
git_patch_free(patch);
git_diff_free(diff);
git_index_free(index);
}
/**
* ggit_patch_new_from_diff:
* @diff: a #GgitDiff.
* @idx: index into diff list.
* @error: a #GError for error reporting, or %NULL.
*
* The #GgitPatch is a newly created object contains the text diffs
* for the delta. You have to call ggit_patch_unref() when you are
* done with it. You can use the patch object to loop over all the hunks
* and lines in the diff of the one delta.
*
* Returns: (transfer full): a newly created #GgitPatch.
*/
GgitPatch *
ggit_patch_new_from_diff (GgitDiff *diff,
gsize idx,
GError **error)
{
git_patch *patch;
gint ret;
g_return_val_if_fail (GGIT_IS_DIFF (diff), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
ret = git_patch_from_diff (&patch, _ggit_native_get (diff), idx);
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
return NULL;
}
return _ggit_patch_wrap (patch);
}
int diff_foreach_via_iterator(
git_diff *diff,
git_diff_file_cb file_cb,
git_diff_hunk_cb hunk_cb,
git_diff_line_cb line_cb,
void *data)
{
size_t d, 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, 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) {
git_patch_free(patch);
goto abort;
}
/* if there are no changes, then the patch will be NULL */
if (!patch) {
cl_assert(delta->status == GIT_DELTA_UNMODIFIED ||
(delta->flags & GIT_DIFF_FLAG_BINARY) != 0);
continue;
}
if (!hunk_cb && !line_cb) {
git_patch_free(patch);
continue;
}
num_h = git_patch_num_hunks(patch);
for (h = 0; h < num_h; h++) {
const git_diff_hunk *hunk;
size_t l, num_l;
cl_git_pass(git_patch_get_hunk(&hunk, &num_l, patch, h));
if (hunk_cb && hunk_cb(delta, hunk, data) != 0) {
git_patch_free(patch);
goto abort;
}
for (l = 0; l < num_l; ++l) {
const git_diff_line *line;
cl_git_pass(git_patch_get_line_in_hunk(&line, patch, h, l));
if (line_cb &&
line_cb(delta, hunk, line, data) != 0) {
git_patch_free(patch);
goto abort;
}
}
}
git_patch_free(patch);
}
return 0;
abort:
giterr_clear();
return GIT_EUSER;
}
int git_diff_get_stats(
git_diff_stats **out,
git_diff *diff)
{
size_t i, deltas;
size_t total_insertions = 0, total_deletions = 0;
git_diff_stats *stats = NULL;
int error = 0;
assert(out && diff);
stats = git__calloc(1, sizeof(git_diff_stats));
GITERR_CHECK_ALLOC(stats);
deltas = git_diff_num_deltas(diff);
stats->filestats = git__calloc(deltas, sizeof(diff_file_stats));
if (!stats->filestats) {
git__free(stats);
return -1;
}
stats->diff = diff;
GIT_REFCOUNT_INC(diff);
for (i = 0; i < deltas && !error; ++i) {
git_patch *patch = NULL;
size_t add = 0, remove = 0, namelen;
const git_diff_delta *delta;
if ((error = git_patch_from_diff(&patch, diff, i)) < 0)
break;
/* keep a count of renames because it will affect formatting */
delta = patch->delta;
/* TODO ugh */
namelen = strlen(delta->new_file.path);
if (strcmp(delta->old_file.path, delta->new_file.path) != 0) {
namelen += strlen(delta->old_file.path);
stats->renames++;
}
/* and, of course, count the line stats */
error = git_patch_line_stats(NULL, &add, &remove, patch);
git_patch_free(patch);
stats->filestats[i].insertions = add;
stats->filestats[i].deletions = remove;
total_insertions += add;
total_deletions += remove;
if (stats->max_name < namelen)
stats->max_name = namelen;
if (stats->max_filestat < add + remove)
stats->max_filestat = add + remove;
}
stats->files_changed = deltas;
stats->insertions = total_insertions;
stats->deletions = total_deletions;
stats->max_digits = digits_for_value(stats->max_filestat + 1);
if (error < 0) {
git_diff_stats_free(stats);
stats = NULL;
}
*out = stats;
return error;
}
void QGit::commitDiffContent(QString first, QString second, QList<QString> files)
{
git_commit *first_commit = nullptr, *second_commit = nullptr;
git_object *first_obj = nullptr, *second_obj = nullptr;
git_tree *first_tree = nullptr, *second_tree = nullptr;
const git_diff_delta *delta = nullptr;
git_repository *repo = nullptr;
git_patch *patch = nullptr;
QList<QGitDiffFile> items;
git_diff *diff = nullptr;
QGitError error;
int res = 0;
try {
res = git_repository_open(&repo, m_path.absolutePath().toUtf8().constData());
if (res)
{
throw QGitError("git_repository_open", res);
}
if (!first.isEmpty())
{
res = git_revparse_single(&first_obj, repo, first.toLatin1());
if (res)
{
throw QGitError("git_revparse_single(first)", res);
}
res = git_commit_lookup(&first_commit, repo, git_object_id(first_obj));
if (res)
{
throw QGitError("git_commit_lookup(first)", res);
}
res = git_commit_tree(&first_tree, first_commit);
if (res)
{
throw QGitError("git_commit_tree(first)", res);
}
}
if (second == "staged")
{
git_diff_options options;
res = git_revparse_single(&first_obj, repo, "HEAD^{tree}");
if (res)
{
throw QGitError("git_revparse_single(staged)", res);
}
res = git_tree_lookup(&first_tree, repo, git_object_id(first_obj));
if (res)
{
throw QGitError("git_tree_lookup(staged)", res);
}
memset(&options, 0, sizeof(options));
options.version = GIT_DIFF_OPTIONS_VERSION;
options.flags = GIT_DIFF_INCLUDE_UNTRACKED | GIT_DIFF_SHOW_UNTRACKED_CONTENT;
options.context_lines = 3;
res = git_diff_tree_to_index(&diff, repo, first_tree, nullptr, &options);
if (res)
{
throw QGitError("git_diff_tree_to_index(staged)", res);
}
}
else if (second == "unstaged")
{
git_diff_options options;
memset(&options, 0, sizeof(options));
options.version = GIT_DIFF_OPTIONS_VERSION;
options.flags = GIT_DIFF_INCLUDE_UNTRACKED | GIT_DIFF_SHOW_UNTRACKED_CONTENT;
options.context_lines = 3;
res = git_diff_index_to_workdir(&diff, repo, nullptr, &options);
if (res)
{
throw QGitError("git_diff_index_to_workdir", res);
}
}
else
{
res = git_revparse_single(&second_obj, repo, second.toLatin1());
if (res)
{
throw QGitError("git_revparse_single(second)", res);
}
res = git_commit_lookup(&second_commit, repo, git_object_id(second_obj));
if (res)
{
throw QGitError("git_commit_lookup(second)", res);
}
res = git_commit_tree(&second_tree, second_commit);
if (res)
{
throw QGitError("git_commit_tree(second)", res);
}
res = git_diff_tree_to_tree(&diff, repo, first_tree, second_tree, nullptr);
if (res)
{
throw QGitError("git_diff_tree_to_tree", res);
}
}
size_t _count = git_diff_num_deltas(diff);
for(size_t c = 0; c < _count; c++)
{
delta = git_diff_get_delta(diff, c);
QGitDiffFile item(delta);
if (files.contains(item.new_file().path()))
{
res = git_patch_from_diff(&patch, diff, c);
if (res)
{
throw QGitError("git_patch_from_diff", res);
}
size_t hunks = git_patch_num_hunks(patch);
for(size_t hunk_cnt = 0; hunk_cnt < hunks; hunk_cnt++) {
const git_diff_hunk *hunk = nullptr;
res = git_patch_get_hunk(&hunk, nullptr, patch, hunk_cnt);
if (res)
{
throw QGitError("git_patch_get_hunk", res);
}
QGitDiffHunk hunkObj(hunk);
const git_diff_line *line = nullptr;
int lines = git_patch_num_lines_in_hunk(patch, hunk_cnt);
if (lines > 0)
{
for(int line_cnt = 0; line_cnt < lines; line_cnt++) {
res = git_patch_get_line_in_hunk(&line, patch, hunk_cnt, static_cast<size_t>(line_cnt));
if (res)
{
throw QGitError("git_patch_get_line_in_hunk", res);
}
hunkObj.addLine(line);
}
}
item.addHunk(hunkObj);
}
items.append(item);
}
}
} catch(const QGitError &ex) {
error = ex;
}
emit commitDiffContentReply(first, second, items, error);
}
