openstack/deb-python-pygit2
Code Issues Proposed changes

Merge remote branch 'perth/master'

Browse Source
This commit is contained in:
J. David Ibáñez
2012-05-31 13:32:25 +02:00
parent a55d4da18a d054788d19
commit 1e1750f8da
14 changed files with 259 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/pygit2/types.h
View File

@@ -29,6 +29,7 @@ OBJECT_STRUCT(Blob, git_blob, blob)
OBJECT_STRUCT(Tag, git_tag, tag)
OBJECT_STRUCT(Index, git_index, index)
OBJECT_STRUCT(Walker, git_revwalk, walk)
OBJECT_STRUCT(Diff, git_diff_list, diff)
typedef struct {
PyObject_HEAD
@@ -36,12 +37,6 @@ typedef struct {
const git_tree_entry *entry;
} TreeEntry;
typedef struct {
PyObject_HEAD
PyObject *a;
PyObject *b;
} Diff;
typedef struct {
PyObject_HEAD
int old_start;
@@ -50,8 +45,7 @@ typedef struct {
int new_start;
int new_lines;
char* new_file;
PyObject *old_data;
PyObject *new_data;
PyObject *data;
} Hunk;
typedef struct {

61
src/pygit2.c
View File

@@ -236,6 +236,67 @@ moduleinit(PyObject* m)
/* Flags for ignored files */
PyModule_AddIntConstant(m, "GIT_STATUS_IGNORED", GIT_STATUS_IGNORED);
/* Git diff flags */
PyModule_AddIntConstant(m, "GIT_DIFF_NORMAL", GIT_DIFF_NORMAL);
PyModule_AddIntConstant(m, "GIT_DIFF_REVERSE", GIT_DIFF_REVERSE);
PyModule_AddIntConstant(m, "GIT_DIFF_FORCE_TEXT", GIT_DIFF_FORCE_TEXT);
PyModule_AddIntConstant(m, "GIT_DIFF_IGNORE_WHITESPACE",
GIT_DIFF_IGNORE_WHITESPACE);
PyModule_AddIntConstant(m, "GIT_DIFF_IGNORE_WHITESPACE_CHANGE",
GIT_DIFF_IGNORE_WHITESPACE_CHANGE);
PyModule_AddIntConstant(m, "GIT_DIFF_IGNORE_WHITESPACE_EOL",
GIT_DIFF_IGNORE_WHITESPACE_EOL);
PyModule_AddIntConstant(m, "GIT_DIFF_IGNORE_SUBMODULES",
GIT_DIFF_IGNORE_SUBMODULES);
PyModule_AddIntConstant(m, "GIT_DIFF_PATIENCE", GIT_DIFF_PATIENCE);
PyModule_AddIntConstant(m, "GIT_DIFF_INCLUDE_IGNORED",
GIT_DIFF_INCLUDE_IGNORED);
PyModule_AddIntConstant(m, "GIT_DIFF_INCLUDE_UNTRACKED",
GIT_DIFF_INCLUDE_UNTRACKED);
PyModule_AddIntConstant(m, "GIT_DIFF_INCLUDE_UNMODIFIED",
GIT_DIFF_INCLUDE_UNMODIFIED);
PyModule_AddIntConstant(m, "GIT_DIFF_RECURSE_UNTRACKED_DIRS",
GIT_DIFF_RECURSE_UNTRACKED_DIRS);
/* Flags for diffed files */
PyModule_AddIntConstant(m, "GIT_DIFF_FILE_VALID_OID",
GIT_DIFF_FILE_VALID_OID);
PyModule_AddIntConstant(m, "GIT_DIFF_FILE_FREE_PATH",
GIT_DIFF_FILE_FREE_PATH);
PyModule_AddIntConstant(m, "GIT_DIFF_FILE_BINARY", GIT_DIFF_FILE_BINARY);
PyModule_AddIntConstant(m, "GIT_DIFF_FILE_NOT_BINARY",
GIT_DIFF_FILE_NOT_BINARY);
PyModule_AddIntConstant(m, "GIT_DIFF_FILE_FREE_DATA",
GIT_DIFF_FILE_FREE_DATA);
PyModule_AddIntConstant(m, "GIT_DIFF_FILE_UNMAP_DATA",
GIT_DIFF_FILE_UNMAP_DATA);
/* Flags for diff deltas */
PyModule_AddIntConstant(m, "GIT_DELTA_UNMODIFIED", GIT_DELTA_UNMODIFIED);
PyModule_AddIntConstant(m, "GIT_DELTA_ADDED", GIT_DELTA_ADDED);
PyModule_AddIntConstant(m, "GIT_DELTA_DELETED", GIT_DELTA_DELETED);
PyModule_AddIntConstant(m, "GIT_DELTA_MODIFIED", GIT_DELTA_MODIFIED);
PyModule_AddIntConstant(m, "GIT_DELTA_RENAMED", GIT_DELTA_RENAMED);
PyModule_AddIntConstant(m, "GIT_DELTA_COPIED", GIT_DELTA_COPIED);
PyModule_AddIntConstant(m, "GIT_DELTA_IGNORED", GIT_DELTA_IGNORED);
PyModule_AddIntConstant(m, "GIT_DELTA_UNTRACKED", GIT_DELTA_UNTRACKED);
/* Flags for diffed lines origin */
PyModule_AddIntConstant(m, "GIT_DIFF_LINE_CONTEXT", GIT_DIFF_LINE_CONTEXT);
PyModule_AddIntConstant(m, "GIT_DIFF_LINE_ADDITION",
GIT_DIFF_LINE_ADDITION);
PyModule_AddIntConstant(m, "GIT_DIFF_LINE_DELETION",
GIT_DIFF_LINE_DELETION);
PyModule_AddIntConstant(m, "GIT_DIFF_LINE_ADD_EOFNL",
GIT_DIFF_LINE_ADD_EOFNL);
PyModule_AddIntConstant(m, "GIT_DIFF_LINE_DEL_EOFNL",
GIT_DIFF_LINE_DEL_EOFNL);
PyModule_AddIntConstant(m, "GIT_DIFF_LINE_FILE_HDR",
GIT_DIFF_LINE_FILE_HDR);
PyModule_AddIntConstant(m, "GIT_DIFF_LINE_HUNK_HDR",
GIT_DIFF_LINE_HUNK_HDR);
PyModule_AddIntConstant(m, "GIT_DIFF_LINE_BINARY", GIT_DIFF_LINE_BINARY);
return m;
}

151
src/pygit2/diff.c
View File

@@ -13,62 +13,15 @@ extern PyTypeObject IndexType;
extern PyTypeObject DiffType;
extern PyTypeObject HunkType;
int diff_get_list(Diff *diff, git_diff_options* opts, git_diff_list** list)
{
int err = -1;
if(diff->b == NULL) {
if(PyObject_TypeCheck(diff->a, &TreeType)) {
err = git_diff_workdir_to_tree(
((Tree*) diff->a)->repo->repo,
opts,
((Tree*) diff->a)->tree,
list
);
} else {
err = git_diff_workdir_to_index(
((Index*) diff->a)->repo->repo,
opts,
list
);
}
} else if(DIFF_CHECK_TYPES(diff->a, diff->b, &TreeType, &TreeType)) {
err = git_diff_tree_to_tree(
((Tree*) diff->a)->repo->repo,
opts,
((Tree*) diff->a)->tree,
((Tree*) diff->b)->tree,
list
);
} else if(DIFF_CHECK_TYPES(diff->a, diff->b, &IndexType, &TreeType)) {
err = git_diff_index_to_tree(
((Tree*) diff->b)->repo->repo,
opts,
((Tree*) diff->b)->tree,
list
);
} else if(DIFF_CHECK_TYPES(diff->a, diff->b, &TreeType, &IndexType)) {
err = git_diff_index_to_tree(
((Tree*) diff->a)->repo->repo,
opts,
((Tree*) diff->a)->tree,
list
);
}
return err;
}
static int diff_data_cb(
void *cb_data,
git_diff_delta *delta,
git_diff_range *range,
char usage,
const char *line,
size_t line_len)
char line_origin,
const char *content,
size_t content_len)
{
PyObject *hunks, *tmp;
PyObject *hunks, *data, *tmp;
Hunk *hunk;
Py_ssize_t size;
@@ -81,13 +34,14 @@ static int diff_data_cb(
if (hunk == NULL)
return -1;
tmp = PyBytes_FromStringAndSize(line, line_len);
tmp = PyBytes_FromStringAndSize(content, content_len);
if(usage != GIT_DIFF_LINE_DELETION)
PyBytes_Concat(&hunk->new_data, tmp);
data = Py_BuildValue("(O,i)",
tmp,
line_origin
);
if(usage != GIT_DIFF_LINE_ADDITION)
PyBytes_Concat(&hunk->old_data, tmp);
PyList_Append(hunk->data, data);
return 0;
}
@@ -109,6 +63,8 @@ static int diff_hunk_cb(
}
hunk = (Hunk*)PyType_GenericNew(&HunkType, NULL, NULL);
if (hunk == NULL)
return -1;
hunk->old_start = range->old_start;
hunk->old_lines = range->old_lines;
@@ -136,13 +92,9 @@ static int diff_hunk_cb(
hunk->new_file = "";
}
#if PY_MAJOR_VERSION >= 3
hunk->old_data = Py_BuildValue("y", "");
hunk->new_data = Py_BuildValue("y", "");
#else
hunk->old_data = Py_BuildValue("s", "");
hunk->new_data = Py_BuildValue("s", "");
#endif
if (hunk->data == NULL) {
hunk->data = PyList_New(0);
}
PyList_Append(hunks, (PyObject *)hunk);
@@ -176,30 +128,17 @@ static int diff_file_cb(void *cb_data, git_diff_delta *delta, float progress)
PyObject *
Diff_changes(Diff *self)
{
git_diff_options opts = {0};
git_diff_list *changes;
PyObject *payload;
int err;
err = diff_get_list(self, &opts, &changes);
if(err < 0) {
Error_set(err);
return NULL;
}
payload = PyDict_New();
git_diff_foreach(
changes,
self->diff,
payload,
&diff_file_cb,
&diff_hunk_cb,
&diff_data_cb
);
git_diff_list_free(changes);
return payload;
}
@@ -217,23 +156,12 @@ static int diff_print_cb(
return 0;
}
PyObject *
Diff_patch(Diff *self)
{
git_diff_options opts = {0};
git_diff_list *changes;
int err;
err = diff_get_list(self, &opts, &changes);
if(err < 0) {
Error_set(err);
return NULL;
}
PyObject *patch = PyBytes_FromString("");
git_diff_print_patch(changes, &patch, &diff_print_cb);
git_diff_print_patch(self->diff, &patch, &diff_print_cb);
return patch;
}
@@ -247,14 +175,8 @@ Hunk_init(Hunk *self, PyObject *args, PyObject *kwds)
self->new_start = 0;
self->new_lines = 0;
self->old_data = PyString_FromString("");
if (self->old_data == NULL) {
Py_XDECREF(self);
return -1;
}
self->new_data = PyString_FromString("");
if (self->new_data == NULL) {
self->data = PyList_New(0);
if (self->data == NULL) {
Py_XDECREF(self);
return -1;
}
@@ -265,8 +187,7 @@ Hunk_init(Hunk *self, PyObject *args, PyObject *kwds)
static void
Hunk_dealloc(Hunk *self)
{
Py_XDECREF(self->old_data);
Py_XDECREF(self->new_data);
Py_XDECREF(self->data);
PyObject_Del(self);
}
@@ -274,11 +195,10 @@ PyMemberDef Hunk_members[] = {
{"old_start", T_INT, offsetof(Hunk, old_start), 0, "old start"},
{"old_lines", T_INT, offsetof(Hunk, old_lines), 0, "old lines"},
{"old_file", T_STRING, offsetof(Hunk, old_file), 0, "old file"},
{"old_data", T_OBJECT, offsetof(Hunk, old_data), 0, "old data"},
{"new_start", T_INT, offsetof(Hunk, new_start), 0, "new start"},
{"new_lines", T_INT, offsetof(Hunk, new_lines), 0, "new lines"},
{"new_file", T_STRING, offsetof(Hunk, new_file), 0, "old file"},
{"new_data", T_OBJECT, offsetof(Hunk, new_data), 0, "new data"},
{"data", T_OBJECT, offsetof(Hunk, data), 0, "data"},
{NULL}
};
@@ -323,22 +243,43 @@ PyTypeObject HunkType = {
0, /* tp_new */
};
PyObject *
Diff_merge(Diff *self, PyObject *args)
{
Diff *py_diff;
int err;
if (!PyArg_ParseTuple(args, "O!", &DiffType, &py_diff))
return NULL;
if (py_diff->repo->repo != self->repo->repo)
return Error_set(GIT_ERROR);
err = git_diff_merge(self->diff, py_diff->diff);
if (err < 0)
return Error_set(err);
Py_RETURN_NONE;
}
static void
Diff_dealloc(Diff *self)
{
Py_XDECREF(self->a);
Py_XDECREF(self->b);
git_diff_list_free(self->diff);
Py_XDECREF(self->repo);
PyObject_Del(self);
}
PyGetSetDef Diff_getseters[] = {
{"changes", (getter)Diff_changes, NULL, "raw changes", NULL},
{"patch", (getter)Diff_patch, NULL, "patch", NULL},
{NULL}
};
static PyMethodDef Diff_methods[] = {
{"merge", (PyCFunction)Diff_merge, METH_VARARGS,
"Merge one diff into another."},
{NULL, NULL, 0, NULL}
};
PyTypeObject DiffType = {
PyVarObject_HEAD_INIT(NULL, 0)
@@ -368,7 +309,7 @@ PyTypeObject DiffType = {
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
Diff_methods, /* tp_methods */
0, /* tp_members */
Diff_getseters, /* tp_getset */
0, /* tp_base */

46
src/pygit2/index.c
View File

@@ -7,6 +7,8 @@
#include <pygit2/index.h>
extern PyTypeObject IndexType;
extern PyTypeObject TreeType;
extern PyTypeObject DiffType;
extern PyTypeObject IndexIterType;
extern PyTypeObject IndexEntryType;
@@ -74,6 +76,48 @@ Index_clear(Index *self)
Py_RETURN_NONE;
}
PyObject *
Index_diff_tree(Index *self, PyObject *args)
{
git_diff_options opts = {0};
git_diff_list *diff;
int err;
Diff *py_diff;
PyObject *py_obj = NULL;
if (!PyArg_ParseTuple(args, "|O", &py_obj))
return NULL;
if (py_obj == NULL) {
err = git_diff_workdir_to_index(
self->repo->repo,
&opts,
&diff);
} else if (PyObject_TypeCheck(py_obj, &TreeType)) {
err = git_diff_index_to_tree(
self->repo->repo,
&opts,
((Tree *)py_obj)->tree,
&diff);
} else {
PyErr_SetObject(PyExc_TypeError, py_obj);
return NULL;
}
if (err < 0)
return Error_set(err);
py_diff = PyObject_New(Diff, &DiffType);
if (py_diff) {
Py_INCREF(py_diff);
Py_INCREF(self->repo);
py_diff->repo = self->repo;
py_diff->diff = diff;
}
return (PyObject*)py_diff;
}
PyObject *
Index_find(Index *self, PyObject *py_path)
{
@@ -285,6 +329,8 @@ PyMethodDef Index_methods[] = {
"Add or update an index entry from a file in disk."},
{"clear", (PyCFunction)Index_clear, METH_NOARGS,
"Clear the contents (all the entries) of an index object."},
{"diff", (PyCFunction)Index_diff_tree, METH_VARARGS,
"Diff index to tree."},
{"_find", (PyCFunction)Index_find, METH_O,
"Find the first index of any entries which point to given path in the"
" Git index."},

1
src/pygit2/repository.c
View File

@@ -17,6 +17,7 @@ extern PyTypeObject CommitType;
extern PyTypeObject BlobType;
extern PyTypeObject TagType;
extern PyTypeObject TreeBuilderType;
extern PyTypeObject DiffType;
git_otype
int_to_loose_object_type(int type_id)

37
src/pygit2/tree.c
View File

@@ -232,27 +232,48 @@ Tree_getitem(Tree *self, PyObject *value)
PyObject *
Tree_diff_tree(Tree *self, PyObject *args)
{
git_diff_options opts = {0};
git_diff_list *diff;
int err;
Diff *py_diff;
PyObject *py_obj = NULL;
if (!PyArg_ParseTuple(args, "|O", &py_obj))
return NULL;
if (py_obj != NULL && !PyObject_TypeCheck(py_obj, &TreeType) &&
!PyObject_TypeCheck(py_obj, &IndexType)) {
if (py_obj == NULL) {
err = git_diff_workdir_to_tree(
self->repo->repo,
&opts,
self->tree,
&diff);
} else if (PyObject_TypeCheck(py_obj, &TreeType)) {
err = git_diff_tree_to_tree(
self->repo->repo,
&opts,
self->tree,
((Tree *)py_obj)->tree,
&diff);
} else if (PyObject_TypeCheck(py_obj, &IndexType)) {
err = git_diff_index_to_tree(
((Index *)py_obj)->repo->repo,
&opts,
self->tree,
&diff);
} else {
PyErr_SetObject(PyExc_TypeError, py_obj);
return NULL;
}
if (err < 0)
return Error_set(err);
py_diff = PyObject_New(Diff, &DiffType);
if (py_diff) {
Py_INCREF(py_diff);
Py_INCREF(self);
Py_XINCREF(py_obj);
py_diff->a = (PyObject*) self;
py_diff->b = (PyObject*) py_obj;
Py_INCREF(self->repo);
py_diff->repo = self->repo;
py_diff->diff = diff;
}
return (PyObject*)py_diff;

BIN
test/data/testrepo.git/objects/2a/d1d3456c5c4a1c9e40aeeddb9cd20b409623c8 Normal file
View File

Binary file not shown.

2
test/data/testrepo.git/objects/2c/dae28389c059815e951d0bb9eed6533f61a46b Normal file
View File

@@ -0,0 +1,2 @@
x<01>OIj1<10>Y<EFBFBD><59><EFBFBD>A<EFBFBD>֑ <20>}<7D>!д<><1E>̂<EFBFBD>
~~<7E>I^<5E>[<15>PE<50><7<01><>E:3<>RMu>D

1
test/data/testrepo.git/objects/39/a3001fcc2b9541fdcf4be2d662618a5d213f47 Normal file
View File

@@ -0,0 +1 @@
x<01>O9N1$<24>+:G<>z|<7C>=B<><42>|<7C>G{m-s<><73><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/ <20>R<1D>J<EFBFBD><4A>6<06><>w"p*<2A>蝵Q<E89DB5>4'CK^<5E><>b<EFBFBD><62>&/NU<>G<><47>1<EFBFBD>B=<3D><><EFBFBD>4)<29><><EFBFBD>1)늝g<EB8A9D>1<>1qBn\<5C><1F><1D><>AWx9d}<7D><><EFBFBD><1E>[<5B><>!<21><><EFBFBD>&<26><>F<EFBFBD><46><EFBFBD>g<EFBFBD>E<><19><>ϸ<EFBFBD><CFB8><EFBFBD>g` 9p<39><70>>)<1E><>c<EFBFBD>j<EFBFBD>.4<EFBFBD>+<01><><EFBFBD><EFBFBD>]<5D>̝O<CC9D><4F><EFBFBD>W)<29><01>M]=

BIN
test/data/testrepo.git/objects/6a/270c81bc80b59591e0d2e3abd7d03450c0c395 Normal file
View File

Binary file not shown.

BIN
test/data/testrepo.git/objects/72/abb8755b2cc6c4e40fd9f50f54384d973a2f22 Normal file
View File

Binary file not shown.

BIN
test/data/testrepo.git/objects/97/d615e1bc273c40c94a726814e7b93fdb5a1b36 Normal file
View File

Binary file not shown.

2
test/data/testrepo.git/refs/heads/master
View File

@@ -1 +1 @@
5fe808e8953c12735680c257f56600cb0de44b10
2cdae28389c059815e951d0bb9eed6533f61a46b

51
test/test_diff.py
View File

@@ -39,6 +39,7 @@ __author__ = 'Nico.Geyso@FU-Berlin.de (Nico von Geyso)'
COMMIT_SHA1_1 = '5fe808e8953c12735680c257f56600cb0de44b10'
COMMIT_SHA1_2 = 'c2792cfa289ae6321ecf2cd5806c2194b0fd070c'
COMMIT_SHA1_3 = '2cdae28389c059815e951d0bb9eed6533f61a46b'
PATCH = b"""diff --git a/a b/a
index 7f129fd..af431f2 100644
@@ -57,14 +58,14 @@ index 297efb8..0000000
"""
DIFF_INDEX_EXPECTED = [
"staged_changes",
"staged_changes_file_deleted",
"staged_changes_file_modified",
"staged_delete",
"staged_delete_file_modified",
"staged_new",
"staged_new_file_deleted",
"staged_new_file_modified"
'staged_changes',
'staged_changes_file_deleted',
'staged_changes_file_modified',
'staged_delete',
'staged_delete_file_modified',
'staged_new',
'staged_new_file_deleted',
'staged_new_file_modified'
]
DIFF_WORKDIR_EXPECTED = [
@@ -130,8 +131,38 @@ class DiffTest(utils.BareRepoTestCase):
self.assertEqual(hunk.old_file, 'a')
self.assertEqual(hunk.new_file, 'a')
self.assertEqual(hunk.old_data, b'a contents 2\n')
self.assertEqual(hunk.new_data, b'a contents\n')
#self.assertEqual(hunk.data[0][0], b'a contents 2\n')
#self.assertEqual(hunk.data[1][0], b'a contents\n')
def test_diff_merge(self):
commit_a = self.repo[COMMIT_SHA1_1]
commit_b = self.repo[COMMIT_SHA1_2]
commit_c = self.repo[COMMIT_SHA1_3]
diff_b = commit_a.tree.diff(commit_b.tree)
self.assertIsNotNone(diff_b)
diff_c = commit_b.tree.diff(commit_c.tree)
self.assertIsNotNone(diff_c)
self.assertNotIn(('b','b', 3), diff_b.changes['files'])
self.assertIn(('b','b', 3), diff_c.changes['files'])
diff_b.merge(diff_c)
self.assertIn(('b','b', 3), diff_b.changes['files'])
hunk = diff_b.changes['hunks'][1]
self.assertEqual(hunk.old_start, 1)
self.assertEqual(hunk.old_lines, 0)
self.assertEqual(hunk.new_start, 1)
self.assertEqual(hunk.new_lines, 0)
self.assertEqual(hunk.old_file, 'b')
self.assertEqual(hunk.new_file, 'b')
#self.assertEqual(hunk.data[0][0], b'b contents\n')
#self.assertEqual(hunk.data[1][0], b'b contents 2\n')
def test_diff_patch(self):
commit_a = self.repo[COMMIT_SHA1_1]