Rename flag to flags in Blob's diff/diff_to_buffer

Also now Tree.diff_to_workdir accepts keyword arguments.

Author: jdavid

CHANGELOG.md

@@ -1,4 +1,4 @@
-# 1.17.1 (UNRELEASED)
+# 1.18.0 (UNRELEASED)
 
 - Upgrade Linux Glibc wheels to `manylinux_2_28`
 
@@ -17,6 +17,12 @@
 - New `proxy` optional argument in `clone_repository(...)`
   [#1354](https://github.com/libgit2/pygit2/pull/1354)
 
+- New optional arguments `context_lines` and `interhunk_lines` in `Blob.diff(...)` ; and
+  now `Repository.diff(...)` honors these two arguments when the objects diffed are blobs.
+  [#1360](https://github.com/libgit2/pygit2/pull/1360)
+
+- Now `Tree.diff_to_workdir(...)` accepts keyword arguments, not just positional.
+
 - Fix when a reference name has non UTF-8 chars
   [#1329](https://github.com/libgit2/pygit2/pull/1329)
 
@@ -34,12 +40,20 @@
 - CI: Use ARM runner for tests and wheels
   [#1346](https://github.com/libgit2/pygit2/pull/1346)
 
+- Build and CI updates
+  [#1363](https://github.com/libgit2/pygit2/pull/1363)
+
 Deprecations:
 
 - Passing str to `Repository.merge(...)` is deprecated,
   instead pass an oid object (or a commit, or a reference)
   [#1349](https://github.com/libgit2/pygit2/pull/1349)
 
+Breaking changes:
+
+- Keyword argument `flag` has been renamed to `flags` in `Blob.diff(...)` and
+  `Blob.diff_to_buffer(...)`
+
 
 # 1.17.0 (2025-01-08)
 

pygit2/repository.py

@@ -521,29 +521,30 @@ def diff(
         a = self.__whatever_to_tree_or_blob(a)
         b = self.__whatever_to_tree_or_blob(b)
 
-        opt_keys = ['flags', 'context_lines', 'interhunk_lines']
-        opt_values = [int(flags), context_lines, interhunk_lines]
+        options = {
+            'flags': int(flags),
+            'context_lines': context_lines,
+            'interhunk_lines': interhunk_lines,
+        }
 
         # Case 1: Diff tree to tree
         if isinstance(a, Tree) and isinstance(b, Tree):
-            return a.diff_to_tree(b, **dict(zip(opt_keys, opt_values)))
+            return a.diff_to_tree(b, **options)
 
         # Case 2: Index to workdir
         elif a is None and b is None:
-            return self.index.diff_to_workdir(*opt_values)
+            return self.index.diff_to_workdir(**options)
 
         # Case 3: Diff tree to index or workdir
         elif isinstance(a, Tree) and b is None:
             if cached:
-                return a.diff_to_index(self.index, *opt_values)
+                return a.diff_to_index(self.index, **options)
             else:
-                return a.diff_to_workdir(*opt_values)
+                return a.diff_to_workdir(**options)
 
         # Case 4: Diff blob to blob
         if isinstance(a, Blob) and isinstance(b, Blob):
-            opt_values.insert(1, 'file')
-            opt_values.insert(1, 'file')
-            return a.diff(b, *opt_values)
+            return a.diff(b, **options)
 
         raise ValueError('Only blobs and treeish can be diffed')
 

src/blob.c

@@ -41,7 +41,7 @@ extern PyObject *GitError;
 extern PyTypeObject BlobType;
 
 PyDoc_STRVAR(Blob_diff__doc__,
-  "diff([blob: Blob, flag: int = GIT_DIFF_NORMAL, old_as_path: str, new_as_path: str]) -> Patch\n"
+  "diff([blob: Blob, flags: int = GIT_DIFF_NORMAL, old_as_path: str, new_as_path: str]) -> Patch\n"
   "\n"
   "Directly generate a :py:class:`pygit2.Patch` from the difference\n"
   "between two blobs.\n"
@@ -53,8 +53,8 @@ PyDoc_STRVAR(Blob_diff__doc__,
   "blob : Blob\n"
   "    The :py:class:`~pygit2.Blob` to diff.\n"
   "\n"
-  "flag\n"
-  "    A GIT_DIFF_* constant.\n"
+  "flags\n"
+  "    A combination of GIT_DIFF_* constant.\n"
   "\n"
   "old_as_path : str\n"
   "    Treat old blob as if it had this filename.\n"
@@ -78,7 +78,7 @@ Blob_diff(Blob *self, PyObject *args, PyObject *kwds)
     char *old_as_path = NULL, *new_as_path = NULL;
     Blob *other = NULL;
     int err;
-    char *keywords[] = {"blob", "flag", "old_as_path", "new_as_path", "context_lines", "interhunk_lines", NULL};
+    char *keywords[] = {"blob", "flags", "old_as_path", "new_as_path", "context_lines", "interhunk_lines", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O!IssHH", keywords,
                                      &BlobType, &other, &opts.flags,
@@ -100,7 +100,7 @@ Blob_diff(Blob *self, PyObject *args, PyObject *kwds)
 
 
 PyDoc_STRVAR(Blob_diff_to_buffer__doc__,
-  "diff_to_buffer(buffer: bytes = None, flag: int = GIT_DIFF_NORMAL[, old_as_path: str, buffer_as_path: str]) -> Patch\n"
+  "diff_to_buffer(buffer: bytes = None, flags: int = GIT_DIFF_NORMAL[, old_as_path: str, buffer_as_path: str]) -> Patch\n"
   "\n"
   "Directly generate a :py:class:`~pygit2.Patch` from the difference\n"
   "between a blob and a buffer.\n"
@@ -112,8 +112,8 @@ PyDoc_STRVAR(Blob_diff_to_buffer__doc__,
   "buffer : bytes\n"
   "    Raw data for new side of diff.\n"
   "\n"
-  "flag\n"
-  "    A GIT_DIFF_* constant.\n"
+  "flags\n"
+  "    A combination of GIT_DIFF_* constants.\n"
   "\n"
   "old_as_path : str\n"
   "    Treat old blob as if it had this filename.\n"
@@ -130,8 +130,7 @@ Blob_diff_to_buffer(Blob *self, PyObject *args, PyObject *kwds)
     const char *buffer = NULL;
     Py_ssize_t buffer_len;
     int err;
-    char *keywords[] = {"buffer", "flag", "old_as_path", "buffer_as_path",
-                        NULL};
+    char *keywords[] = {"buffer", "flags", "old_as_path", "buffer_as_path", NULL};
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|z#Iss", keywords,
                                      &buffer, &buffer_len, &opts.flags,

src/tree.c

@@ -222,14 +222,16 @@ PyDoc_STRVAR(Tree_diff_to_workdir__doc__,
   "    the hunks will be merged into a one.\n");
 
 PyObject *
-Tree_diff_to_workdir(Tree *self, PyObject *args)
+Tree_diff_to_workdir(Tree *self, PyObject *args, PyObject *kwds)
 {
     git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
     git_diff *diff;
     int err;
 
-    if (!PyArg_ParseTuple(args, "|IHH", &opts.flags, &opts.context_lines,
-                                        &opts.interhunk_lines))
+    char *keywords[] = {"flags", "context_lines", "interhunk_lines", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|IHH", keywords, &opts.flags,
+                                     &opts.context_lines, &opts.interhunk_lines))
         return NULL;
 
     if (Object__load((Object*)self) == NULL) { return NULL; } // Lazy load
@@ -354,8 +356,7 @@ Tree_diff_to_tree(Tree *self, PyObject *args, PyObject *kwds)
     git_diff *diff;
     git_tree *from, *to = NULL, *tmp;
     int err, swap = 0;
-    char *keywords[] = {"obj", "flags", "context_lines", "interhunk_lines",
-                        "swap", NULL};
+    char *keywords[] = {"obj", "flags", "context_lines", "interhunk_lines", "swap", NULL};
 
     Tree *other = NULL;
 
@@ -406,7 +407,7 @@ PyMappingMethods Tree_as_mapping = {
 
 PyMethodDef Tree_methods[] = {
     METHOD(Tree, diff_to_tree, METH_VARARGS | METH_KEYWORDS),
-    METHOD(Tree, diff_to_workdir, METH_VARARGS),
+    METHOD(Tree, diff_to_workdir, METH_VARARGS | METH_KEYWORDS),
     METHOD(Tree, diff_to_index, METH_VARARGS | METH_KEYWORDS),
     {NULL}
 };