Merge branch 'master' into patch_tests

Author: brandonio21

src/diff.c

@@ -475,13 +475,92 @@ PyTypeObject DiffIterType = {
     (iternextfunc) DiffIter_iternext,          /* tp_iternext       */
 };
 
+PyObject *
+diff_get_delta_byindex(git_diff *diff, size_t idx)
+{
+    const git_diff_delta *delta = git_diff_get_delta(diff, idx);
+    if (delta == NULL) {
+        PyErr_SetObject(PyExc_IndexError, PyInt_FromSize_t(idx));
+        return NULL;
+    }
+
+    return (PyObject*) wrap_diff_delta(delta);
+}
+
+PyObject *
+DeltasIter_iternext(DeltasIter *self)
+{
+    if (self->i < self->n)
+        return diff_get_delta_byindex(self->diff->diff, self->i++);
+
+    PyErr_SetNone(PyExc_StopIteration);
+    return NULL;
+}
+
+void
+DeltasIter_dealloc(DeltasIter *self)
+{
+    Py_CLEAR(self->diff);
+    PyObject_Del(self);
+}
+
+PyDoc_STRVAR(DeltasIter__doc__, "Deltas iterator object.");
+
+PyTypeObject DeltasIterType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "_pygit2.DeltasIter",                      /* tp_name           */
+    sizeof(DeltasIter),                        /* tp_basicsize      */
+    0,                                         /* tp_itemsize       */
+    (destructor)DeltasIter_dealloc,            /* tp_dealloc        */
+    0,                                         /* tp_print          */
+    0,                                         /* tp_getattr        */
+    0,                                         /* tp_setattr        */
+    0,                                         /* tp_compare        */
+    0,                                         /* tp_repr           */
+    0,                                         /* tp_as_number      */
+    0,                                         /* tp_as_sequence    */
+    0,                                         /* tp_as_mapping     */
+    0,                                         /* tp_hash           */
+    0,                                         /* tp_call           */
+    0,                                         /* tp_str            */
+    0,                                         /* tp_getattro       */
+    0,                                         /* tp_setattro       */
+    0,                                         /* tp_as_buffer      */
+    Py_TPFLAGS_DEFAULT,                        /* tp_flags          */
+    DeltasIter__doc__,                         /* tp_doc            */
+    0,                                         /* tp_traverse       */
+    0,                                         /* tp_clear          */
+    0,                                         /* tp_richcompare    */
+    0,                                         /* tp_weaklistoffset */
+    PyObject_SelfIter,                         /* tp_iter           */
+    (iternextfunc) DeltasIter_iternext,        /* tp_iternext       */
+};
+
+
 Py_ssize_t
 Diff_len(Diff *self)
 {
     assert(self->diff);
     return (Py_ssize_t)git_diff_num_deltas(self->diff);
 }
 
+PyDoc_STRVAR(Diff_deltas__doc__, "Iterate over the diff deltas.");
+
+PyObject *
+Diff_deltas__get__(Diff *self)
+{
+    DeltasIter *iter;
+
+    iter = PyObject_New(DeltasIter, &DeltasIterType);
+    if (iter != NULL) {
+        Py_INCREF(self);
+        iter->diff = self;
+        iter->i = 0;
+        iter->n = git_diff_num_deltas(self->diff);
+    }
+    return (PyObject*)iter;
+}
+
 PyDoc_STRVAR(Diff_patch__doc__,
     "Patch diff string. Can be None in some cases, such as empty commits.");
 
@@ -814,7 +893,7 @@ Diff_getitem(Diff *self, PyObject *value)
     return diff_get_patch_byindex(self->diff, i);
 }
 
-PyDoc_STRVAR(Diff_stats__doc__, "Accumulate diff statistics for all patches");
+PyDoc_STRVAR(Diff_stats__doc__, "Accumulate diff statistics for all patches.");
 
 PyObject *
 Diff_stats__get__(Diff *self)
@@ -831,6 +910,7 @@ Diff_dealloc(Diff *self)
 }
 
 PyGetSetDef Diff_getseters[] = {
+    GETTER(Diff, deltas),
     GETTER(Diff, patch),
     GETTER(Diff, stats),
     {NULL}

src/patch.c

@@ -46,8 +46,7 @@ wrap_patch(git_patch *patch)
     PyObject *py_hunk;
     size_t i, hunk_amounts;
 
-    if (!patch)
-        Py_RETURN_NONE;
+    assert(patch);
 
     py_patch = PyObject_New(Patch, &PatchType);
     if (py_patch) {
@@ -78,9 +77,7 @@ PyDoc_STRVAR(Patch_delta__doc__, "Get the delta associated with a patch.");
 PyObject *
 Patch_delta__get__(Patch *self)
 {
-    if (!self->patch)
-        Py_RETURN_NONE;
-
+    assert(self->patch);
     return wrap_diff_delta(git_patch_get_delta(self->patch));
 }
 
@@ -93,11 +90,8 @@ Patch_line_stats__get__(Patch *self)
     size_t context, additions, deletions;
     int err;
 
-    if (!self->patch)
-        Py_RETURN_NONE;
-
-    err = git_patch_line_stats(&context, &additions, &deletions,
-                               self->patch);
+    assert(self->patch);
+    err = git_patch_line_stats(&context, &additions, &deletions, self->patch);
     if (err < 0)
         return Error_set(err);
 
@@ -124,11 +118,14 @@ Patch_create_from(PyObject *self, PyObject *args, PyObject *kwds)
   Py_ssize_t oldbuflen, newbuflen;
   int err;
 
-  char *keywords[] = {"old", "new", "flag", "old_as_path", "new_as_path", NULL};
+  char *keywords[] = {"old", "new", "old_as_path", "new_as_path",
+                      "flag", "context_lines", "interhunk_lines",
+                      NULL};
 
-  if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|Izz", keywords,
-                                   &oldobj, &newobj, &opts.flags,
-                                   &old_as_path, &new_as_path))
+  if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|zzIHH", keywords,
+                                   &oldobj, &newobj, &old_as_path, &new_as_path,
+                                   &opts.flags, &opts.context_lines,
+                                   &opts.interhunk_lines))
     return NULL;
 
   if (oldobj != Py_None && PyObject_TypeCheck(oldobj, &BlobType))
@@ -168,12 +165,11 @@ Patch_create_from(PyObject *self, PyObject *args, PyObject *kwds)
     err = git_patch_from_buffers(&patch, oldbuf, oldbuflen, old_as_path,
                                  newbuf, newbuflen, new_as_path, &opts);
   }
-  
+
   if (err < 0)
     return Error_set(err);
 
   return wrap_patch(patch);
-    
 }
 
 
@@ -183,24 +179,18 @@ PyDoc_STRVAR(Patch_patch__doc__,
 PyObject *
 Patch_patch__get__(Patch *self)
 {
-  git_buf buf = {NULL};
-  int err = GIT_ERROR;
-  PyObject *py_patch = NULL;
-
-  err = git_patch_to_buf(&buf, self->patch);
-
-  if (!self->patch)
-      Py_RETURN_NONE;
-
-  if (err < 0)
-    goto cleanup;
+    git_buf buf = {NULL};
+    int err;
+    PyObject *py_patch;
 
-  py_patch = to_unicode(buf.ptr, NULL, NULL);
-  git_buf_free(&buf);
+    assert(self->patch);
+    err = git_patch_to_buf(&buf, self->patch);
+    if (err < 0)
+        return Error_set(err);
 
-cleanup:
+    py_patch = to_unicode(buf.ptr, NULL, NULL);
     git_buf_free(&buf);
-    return (err < 0) ? Error_set(err) : py_patch;
+    return py_patch;
 }
 
 PyMethodDef Patch_methods[] = {

src/pygit2.c

@@ -43,6 +43,7 @@ extern PyTypeObject OidType;
 extern PyTypeObject ObjectType;
 extern PyTypeObject CommitType;
 extern PyTypeObject DiffType;
+extern PyTypeObject DeltasIterType;
 extern PyTypeObject DiffIterType;
 extern PyTypeObject DiffDeltaType;
 extern PyTypeObject DiffFileType;
@@ -335,6 +336,7 @@ moduleinit(PyObject* m)
      * Diff
      */
     INIT_TYPE(DiffType, NULL, NULL)
+    INIT_TYPE(DeltasIterType, NULL, NULL)
     INIT_TYPE(DiffIterType, NULL, NULL)
     INIT_TYPE(DiffDeltaType, NULL, NULL)
     INIT_TYPE(DiffFileType, NULL, NULL)

src/types.h

@@ -100,6 +100,13 @@ typedef struct {
 /* git_diff */
 SIMPLE_TYPE(Diff, git_diff, diff)
 
+typedef struct {
+    PyObject_HEAD
+    Diff *diff;
+    size_t i;
+    size_t n;
+} DeltasIter;
+
 typedef struct {
     PyObject_HEAD
     Diff *diff;

test/test_diff.py

@@ -325,6 +325,24 @@ def test_diff_stats(self):
                                  width=80)
         self.assertEqual(STATS_EXPECTED, formatted)
 
+    def test_deltas(self):
+        commit_a = self.repo[COMMIT_SHA1_1]
+        commit_b = self.repo[COMMIT_SHA1_2]
+        diff = commit_a.tree.diff_to_tree(commit_b.tree)
+        deltas = list(diff.deltas)
+        patches = list(diff)
+        self.assertEqual(len(deltas), len(patches))
+        for i, delta in enumerate(deltas):
+            patch_delta = patches[i].delta
+            self.assertEqual(delta.status, patch_delta.status)
+            self.assertEqual(delta.similarity, patch_delta.similarity)
+            self.assertEqual(delta.nfiles, patch_delta.nfiles)
+            self.assertEqual(delta.old_file.id, patch_delta.old_file.id)
+            self.assertEqual(delta.new_file.id, patch_delta.new_file.id)
+
+            # As explained in the libgit2 documentation, flags are not set
+            #self.assertEqual(delta.flags, patch_delta.flags)
+
 
 class BinaryDiffTest(utils.BinaryFileRepoTestCase):
     def test_binary_diff(self):

test/test_patch.py

@@ -156,9 +156,46 @@ def test_patch_create_from_bad_new_type_arg(self):
                 self.repo,
             )
 
+    def test_context_lines(self):
+        old_blob = self.repo[BLOB_OLD_SHA]
+        new_blob = self.repo[BLOB_NEW_SHA]
+
+        patch = pygit2.Patch.create_from(
+            old_blob,
+            new_blob,
+            old_as_path=BLOB_OLD_PATH,
+            new_as_path=BLOB_NEW_PATH,
+        )
+
+        context_count = (
+            len([line for line in patch.patch.splitlines() if line.startswith(" ")])
+        )
+
+        self.assertNotEqual(context_count, 0)
+
+    def test_no_context_lines(self):
+        old_blob = self.repo[BLOB_OLD_SHA]
+        new_blob = self.repo[BLOB_NEW_SHA]
+
+        patch = pygit2.Patch.create_from(
+            old_blob,
+            new_blob,
+            old_as_path=BLOB_OLD_PATH,
+            new_as_path=BLOB_NEW_PATH,
+            context_lines=0,
+        )
+
+        context_count = (
+            len([line for line in patch.patch.splitlines() if line.startswith(" ")])
+        )
+
+        self.assertEqual(context_count, 0)
+
+
     def test_patch_create_blob_blobs(self):
         old_blob = self.repo[self.repo.create_blob(BLOB_OLD_CONTENT)]
         new_blob = self.repo[self.repo.create_blob(BLOB_NEW_CONTENT)]
+
         patch = pygit2.Patch.create_from(
             old_blob,
             new_blob,