#define PY_SSIZE_T_CLEAN

#include <Python.h>

#include <structmember.h>

#include "diff.h"

#include "error.h"

#include "oid.h"

#include "patch.h"

#include "types.h"

#include "utils.h"

extern PyObject *GitError;

extern PyTypeObject TreeType;

extern PyTypeObject IndexType;

extern PyTypeObject DiffType;

extern PyTypeObject DiffDeltaType;

extern PyTypeObject DiffFileType;

extern PyTypeObject DiffHunkType;

extern PyTypeObject DiffLineType;

extern PyTypeObject DiffStatsType;

extern PyTypeObject RepositoryType;

extern PyObject *DeltaStatusEnum;

extern PyObject *DiffFlagEnum;

extern PyObject *FileModeEnum;

PyObject *

wrap_diff(git_diff *diff, Repository *repo)

{

Diff *py_diff;

py_diff = PyObject_New(Diff, &DiffType);

if (py_diff) {

Py_XINCREF(repo);

py_diff->repo = repo;

py_diff->diff = diff;

}

return (PyObject*) py_diff;

}

PyObject *

wrap_diff_file(const git_diff_file *file)

{

DiffFile *py_file;

if (!file)

Py_RETURN_NONE;

py_file = PyObject_New(DiffFile, &DiffFileType);

if (py_file) {

py_file->id = git_oid_to_python(&file->id);

if (file->path) {

py_file->path = strdup(file->path);

py_file->raw_path = PyBytes_FromString(file->path);

} else {

py_file->path = NULL;

py_file->raw_path = NULL;

}

py_file->size = file->size;

py_file->flags = file->flags;

py_file->mode = file->mode;

}

return (PyObject *) py_file;

}

PyObject *

wrap_diff_delta(const git_diff_delta *delta, Diff *diff, size_t idx)

{

DiffDelta *py_delta;

if (!delta)

Py_RETURN_NONE;

py_delta = PyObject_New(DiffDelta, &DiffDeltaType);

if (py_delta) {

py_delta->status = delta->status;

py_delta->flags = delta->flags;

py_delta->similarity = delta->similarity;

py_delta->nfiles = delta->nfiles;

py_delta->old_file = wrap_diff_file(&delta->old_file);

py_delta->new_file = wrap_diff_file(&delta->new_file);

py_delta->diff = diff;

if (diff)

Py_INCREF(diff);

py_delta->idx = idx;

}

return (PyObject *) py_delta;

}

PyObject *

wrap_diff_hunk(Patch *patch, size_t idx)

{

DiffHunk *py_hunk;

const git_diff_hunk *hunk;

size_t lines_in_hunk;

int err;

err = git_patch_get_hunk(&hunk, &lines_in_hunk, patch->patch, idx);

if (err < 0)

return Error_set(err);

py_hunk = PyObject_New(DiffHunk, &DiffHunkType);

if (py_hunk) {

Py_INCREF(patch);

py_hunk->patch = patch;

py_hunk->hunk = hunk;

py_hunk->idx = idx;

py_hunk->n_lines = lines_in_hunk;

}

return (PyObject *) py_hunk;

}

PyObject *

wrap_diff_stats(git_diff *diff)

{

git_diff_stats *stats;

DiffStats *py_stats;

int err;

err = git_diff_get_stats(&stats, diff);

if (err < 0)

return Error_set(err);

py_stats = PyObject_New(DiffStats, &DiffStatsType);

if (!py_stats) {

git_diff_stats_free(stats);

return NULL;

}

py_stats->stats = stats;

return (PyObject *) py_stats;

}

PyObject *

wrap_diff_line(const git_diff_line *line, DiffHunk *hunk)

{

DiffLine *py_line;

py_line = PyObject_New(DiffLine, &DiffLineType);

if (py_line) {

Py_INCREF(hunk);

py_line->hunk = hunk;

py_line->line = line;

}

return (PyObject *) py_line;

}

static void

DiffFile_dealloc(DiffFile *self)

{

Py_CLEAR(self->id);

Py_CLEAR(self->raw_path);

free(self->path);

PyObject_Del(self);

}

PyDoc_STRVAR(DiffFile_from_c__doc__, "Method exposed for _checkout_notify_cb to hook into");

PyObject *

DiffFile_from_c(DiffFile *dummy, PyObject *py_diff_file_ptr)

{

const git_diff_file *diff_file;

char *buffer;

Py_ssize_t length;

/* Here we need to do the opposite conversion from the _pointer getters */

if (PyBytes_AsStringAndSize(py_diff_file_ptr, &buffer, &length))

return NULL;

if (length != sizeof(git_diff_file *)) {

PyErr_SetString(PyExc_TypeError, "passed value is not a pointer");

return NULL;

}

/* the "buffer" contains the pointer */

diff_file = *((const git_diff_file **) buffer);

return wrap_diff_file(diff_file);

}

PyDoc_STRVAR(DiffFile_flags__doc__,

"A combination of enums.DiffFlag constants."

);

PyObject *

DiffFile_flags__get__(DiffFile *self)

{

return pygit2_enum(DiffFlagEnum, self->flags);

}

PyDoc_STRVAR(DiffFile_mode__doc__,

"Mode of the entry (an enums.FileMode constant)."

);

PyObject *

DiffFile_mode__get__(DiffFile *self)

{

return pygit2_enum(FileModeEnum, self->mode);

}

PyDoc_STRVAR(DiffFile_path__doc__, "Path to the entry.");

PyObject *

DiffFile_path__get__(DiffFile *self)

{

if (self->path == NULL)

Py_RETURN_NONE;

return PyUnicode_DecodeFSDefault(self->path);

}

PyMemberDef DiffFile_members[] = {

MEMBER(DiffFile, id, T_OBJECT, "Oid of the item."),

MEMBER(DiffFile, raw_path, T_OBJECT, "Path to the entry (bytes)."),

MEMBER(DiffFile, size, T_LONG, "Size of the entry."),

{NULL}

};

static PyMethodDef DiffFile_methods[] = {

METHOD(DiffFile, from_c, METH_STATIC | METH_O),

{NULL},

};

PyGetSetDef DiffFile_getsetters[] = {

GETTER(DiffFile, flags),

GETTER(DiffFile, mode),

GETTER(DiffFile, path),

{NULL},

};

PyDoc_STRVAR(DiffFile__doc__, "DiffFile object.");

PyTypeObject DiffFileType = {

PyVarObject_HEAD_INIT(NULL, 0)

"_pygit2.DiffFile", /* tp_name */

sizeof(DiffFile), /* tp_basicsize */

0, /* tp_itemsize */

(destructor)DiffFile_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 */

DiffFile__doc__, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

DiffFile_methods, /* tp_methods */

DiffFile_members, /* tp_members */

DiffFile_getsetters, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

0, /* tp_new */

};

PyDoc_STRVAR(DiffDelta_status_char__doc__,

"status_char() -> str\n"

"\n"

"Return the single character abbreviation for a delta status code."

);

PyObject *

DiffDelta_status_char(DiffDelta *self)

{

char status = git_diff_status_char(self->status);

return Py_BuildValue("C", status);

}

static int

DiffDelta_ensure_flags(DiffDelta *self)

{

git_patch *patch = NULL;

const git_diff_delta *delta;

int err;

if (self->diff == NULL)

return 0;

if (self->flags & (GIT_DIFF_FLAG_BINARY | GIT_DIFF_FLAG_NOT_BINARY))

return 0;

err = git_patch_from_diff(&patch, self->diff->diff, self->idx);

if (err < 0)

return err;

delta = git_diff_get_delta(self->diff->diff, self->idx);

if (delta == NULL) {

git_patch_free(patch);

return GIT_ENOTFOUND;

}

self->flags = delta->flags;

git_patch_free(patch);

return 0;

}

PyDoc_STRVAR(DiffDelta_is_binary__doc__,

"True if binary data, False if text, None if not (yet) known."

);

PyObject *

DiffDelta_is_binary__get__(DiffDelta *self)

{

int err;

err = DiffDelta_ensure_flags(self);

if (err < 0)

return Error_set(err);

if (self->flags & GIT_DIFF_FLAG_BINARY)

Py_RETURN_TRUE;

if (self->flags & GIT_DIFF_FLAG_NOT_BINARY)

Py_RETURN_FALSE;

// This means the file has not been loaded, so we don't know whether it's

// binary or text

Py_RETURN_NONE;

}

PyDoc_STRVAR(DiffDelta_status__doc__,

"An enums.DeltaStatus constant."

);

PyObject *

DiffDelta_status__get__(DiffDelta *self)

{

return pygit2_enum(DeltaStatusEnum, self->status);

}

PyDoc_STRVAR(DiffDelta_flags__doc__,

"A combination of enums.DiffFlag constants."

);

PyObject *

DiffDelta_flags__get__(DiffDelta *self)

{

int err;

err = DiffDelta_ensure_flags(self);

if (err < 0)

return Error_set(err);

return pygit2_enum(DiffFlagEnum, self->flags);

}

static void

DiffDelta_dealloc(DiffDelta *self)

{

Py_CLEAR(self->diff);

Py_CLEAR(self->old_file);

Py_CLEAR(self->new_file);

PyObject_Del(self);

}

static PyMethodDef DiffDelta_methods[] = {

METHOD(DiffDelta, status_char, METH_NOARGS),

{NULL}

};

PyMemberDef DiffDelta_members[] = {

MEMBER(DiffDelta, similarity, T_USHORT, "For renamed and copied."),

MEMBER(DiffDelta, nfiles, T_USHORT, "Number of files in the delta."),

MEMBER(DiffDelta, old_file, T_OBJECT, "\"from\" side of the diff."),

MEMBER(DiffDelta, new_file, T_OBJECT, "\"to\" side of the diff."),

{NULL}

};

PyGetSetDef DiffDelta_getsetters[] = {

GETTER(DiffDelta, is_binary),

GETTER(DiffDelta, status),

GETTER(DiffDelta, flags),

{NULL}

};

PyDoc_STRVAR(DiffDelta__doc__, "DiffDelta object.");

PyTypeObject DiffDeltaType = {

PyVarObject_HEAD_INIT(NULL, 0)

"_pygit2.DiffDelta", /* tp_name */

sizeof(DiffDelta), /* tp_basicsize */

0, /* tp_itemsize */

(destructor)DiffDelta_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 */

DiffDelta__doc__, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

DiffDelta_methods, /* tp_methods */

DiffDelta_members, /* tp_members */

DiffDelta_getsetters, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

0, /* tp_new */

};

static void

DiffLine_dealloc(DiffLine *self)

{

Py_CLEAR(self->hunk);

PyObject_Del(self);

}

PyDoc_STRVAR(DiffLine_origin__doc__, "Type of the diff line");

PyObject *

DiffLine_origin__get__(DiffLine *self)

{

return PyUnicode_FromStringAndSize(&(self->line->origin), 1);

}

PyDoc_STRVAR(DiffLine_old_lineno__doc__, "Line number in old file or -1 for added line");

PyObject *

DiffLine_old_lineno__get__(DiffLine *self)

{

return PyLong_FromLong(self->line->old_lineno);

}

PyDoc_STRVAR(DiffLine_new_lineno__doc__, "Line number in new file or -1 for deleted line");

PyObject *

DiffLine_new_lineno__get__(DiffLine *self)

{

return PyLong_FromLong(self->line->new_lineno);

}

PyDoc_STRVAR(DiffLine_num_lines__doc__, "Number of newline characters in content");

PyObject *

DiffLine_num_lines__get__(DiffLine *self)

{

return PyLong_FromLong(self->line->num_lines);

}

PyDoc_STRVAR(DiffLine_content_offset__doc__, "Offset in the original file to the content");

PyObject *

DiffLine_content_offset__get__(DiffLine *self)

{

return PyLong_FromLongLong(self->line->content_offset);

}

PyDoc_STRVAR(DiffLine_content__doc__, "Content of the diff line");

PyObject *

DiffLine_content__get__(DiffLine *self)

{

return to_unicode_n(self->line->content, self->line->content_len, NULL, NULL);

}

PyDoc_STRVAR(DiffLine_raw_content__doc__, "Content of the diff line (byte string)");

PyObject *

DiffLine_raw_content__get__(DiffLine *self)

{

return PyBytes_FromStringAndSize(self->line->content, self->line->content_len);

}

PyGetSetDef DiffLine_getsetters[] = {

GETTER(DiffLine, origin),

GETTER(DiffLine, old_lineno),

GETTER(DiffLine, new_lineno),

GETTER(DiffLine, num_lines),

GETTER(DiffLine, content_offset),

GETTER(DiffLine, content),

GETTER(DiffLine, raw_content),

{NULL}

};

PyDoc_STRVAR(DiffLine__doc__, "DiffLine object.");

PyTypeObject DiffLineType = {

PyVarObject_HEAD_INIT(NULL, 0)

"_pygit2.DiffLine", /* tp_name */

sizeof(DiffLine), /* tp_basicsize */

0, /* tp_itemsize */

(destructor)DiffLine_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 */

DiffLine__doc__, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

0, /* tp_members */

DiffLine_getsetters, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

0, /* tp_new */

};

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);

/* libgit2 may decide not to create a patch if the file is

if (patch == NULL)

Py_RETURN_NONE;

return (PyObject*) wrap_patch(patch, NULL, NULL);

}

PyObject *

DiffIter_iternext(DiffIter *self)

{

if (self->i < self->n)

return diff_get_patch_byindex(self->diff->diff, self->i++);

PyErr_SetNone(PyExc_StopIteration);

return NULL;

}

DiffIter_dealloc(DiffIter *self)

{

Py_CLEAR(self->diff);

PyObject_Del(self);

}

PyDoc_STRVAR(DiffIter__doc__, "Diff iterator object.");

PyTypeObject DiffIterType = {

PyVarObject_HEAD_INIT(NULL, 0)

"_pygit2.DiffIter", /* tp_name */

sizeof(DiffIter), /* tp_basicsize */

0, /* tp_itemsize */

(destructor)DiffIter_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 */

DiffIter__doc__, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

PyObject_SelfIter, /* tp_iter */

(iternextfunc) DiffIter_iternext, /* tp_iternext */

};

PyObject *

diff_get_delta_byindex(git_diff *diff, size_t idx, Diff *parent)

{

const git_diff_delta *delta = git_diff_get_delta(diff, idx);

if (delta == NULL) {

PyErr_SetObject(PyExc_IndexError, PyLong_FromSize_t(idx));

return NULL;

}

return (PyObject*) wrap_diff_delta(delta, parent, idx);

}

PyObject *

DeltasIter_iternext(DeltasIter *self)

{

if (self->i < self->n)

return diff_get_delta_byindex(self->diff->diff, self->i++, self->diff);

PyErr_SetNone(PyExc_StopIteration);

return NULL;

}

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 */

};

Diff_len(Diff *self)

{

assert(self->diff);

return (Py_ssize_t)git_diff_num_deltas(self->diff);

}

PyDoc_STRVAR(Diff_patchid__doc__,

"Corresponding patchid.");

PyObject *

Diff_patchid__get__(Diff *self)

{

git_oid oid;

int err;

err = git_diff_patchid(&oid, self->diff, NULL);

if (err < 0)

return Error_set(err);

return git_oid_to_python(&oid);

}

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.");

PyObject *

Diff_patch__get__(Diff *self)

{

git_buf buf = {NULL};

int err = git_diff_to_buf(&buf, self->diff, GIT_DIFF_FORMAT_PATCH);

if (err < 0)

return Error_set(err);

PyObject *py_patch = to_unicode_n(buf.ptr, buf.size, NULL, NULL);

git_buf_dispose(&buf);

return py_patch;

}

static void

DiffHunk_dealloc(DiffHunk *self)

{

Py_CLEAR(self->patch);

PyObject_Del(self);

}

PyDoc_STRVAR(DiffHunk_old_start__doc__, "Old start.");

PyObject *

DiffHunk_old_start__get__(DiffHunk *self)

{

return PyLong_FromLong(self->hunk->old_start);

}

PyDoc_STRVAR(DiffHunk_old_lines__doc__, "Old lines.");

PyObject *

DiffHunk_old_lines__get__(DiffHunk *self)

{

return PyLong_FromLong(self->hunk->old_lines);

}

PyDoc_STRVAR(DiffHunk_new_start__doc__, "New start.");

PyObject *

DiffHunk_new_start__get__(DiffHunk *self)

{

return PyLong_FromLong(self->hunk->new_start);

}

PyDoc_STRVAR(DiffHunk_new_lines__doc__, "New lines.");

PyObject *

DiffHunk_new_lines__get__(DiffHunk *self)

{

return PyLong_FromLong(self->hunk->new_lines);

}

PyDoc_STRVAR(DiffHunk_header__doc__, "Header.");

PyObject *

DiffHunk_header__get__(DiffHunk *self)

{

return to_unicode_n((const char *) &self->hunk->header,

self->hunk->header_len, NULL, NULL);

}

PyDoc_STRVAR(DiffHunk_lines__doc__, "Lines.");

PyObject *

DiffHunk_lines__get__(DiffHunk *self)

{

PyObject *py_lines;

PyObject *py_line;

const git_diff_line *line;

size_t i;

int err;

// TODO Replace by an iterator

py_lines = PyList_New(self->n_lines);

if (py_lines == NULL)

return NULL;

for (i = 0; i < self->n_lines; ++i) {

err = git_patch_get_line_in_hunk(&line, self->patch->patch, self->idx, i);

if (err < 0) {

Py_DECREF(py_lines);

return Error_set(err);

}

py_line = wrap_diff_line(line, self);

if (py_line == NULL) {

Py_DECREF(py_lines);

return NULL;

}

PyList_SetItem(py_lines, i, py_line);

}

return py_lines;

}

PyGetSetDef DiffHunk_getsetters[] = {

GETTER(DiffHunk, old_start),

GETTER(DiffHunk, old_lines),

GETTER(DiffHunk, new_start),

GETTER(DiffHunk, new_lines),

GETTER(DiffHunk, header),

GETTER(DiffHunk, lines),

{NULL}

};

PyDoc_STRVAR(DiffHunk__doc__, "DiffHunk object.");

PyTypeObject DiffHunkType = {

PyVarObject_HEAD_INIT(NULL, 0)

"_pygit2.DiffHunk", /* tp_name */

sizeof(DiffHunk), /* tp_basicsize */

0, /* tp_itemsize */

(destructor)DiffHunk_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 | Py_TPFLAGS_BASETYPE, /* tp_flags */

DiffHunk__doc__, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

0, /* tp_members */

DiffHunk_getsetters, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

0, /* tp_new */

};

PyDoc_STRVAR(DiffStats_insertions__doc__, "Total number of insertions");

PyObject *

DiffStats_insertions__get__(DiffStats *self)

{

return PyLong_FromSize_t(git_diff_stats_insertions(self->stats));

}

PyDoc_STRVAR(DiffStats_deletions__doc__, "Total number of deletions");

PyObject *

DiffStats_deletions__get__(DiffStats *self)

{

return PyLong_FromSize_t(git_diff_stats_deletions(self->stats));

}

PyDoc_STRVAR(DiffStats_files_changed__doc__, "Total number of files changed");

PyObject *

DiffStats_files_changed__get__(DiffStats *self)

{

return PyLong_FromSize_t(git_diff_stats_files_changed(self->stats));

}

PyDoc_STRVAR(DiffStats_format__doc__,

"format(format: enums.DiffStatsFormat, width: int) -> str\n"

"\n"

"Format the stats as a string.\n"

"\n"

"Returns: str.\n"

"\n"

"Parameters:\n"

"\n"

"format\n"

" The format to use. A combination of DiffStatsFormat constants.\n"

"\n"

"width\n"

" The width of the output. The output will be scaled to fit.");

PyObject *

DiffStats_format(DiffStats *self, PyObject *args, PyObject *kwds)

{

int err, format;

git_buf buf = { 0 };

Py_ssize_t width;

PyObject *str;

char *keywords[] = {"format", "width", NULL};

if (!PyArg_ParseTupleAndKeywords(args, kwds, "in", keywords, &format, &width))

return NULL;

if (width <= 0) {

PyErr_SetString(PyExc_ValueError, "width must be positive");

return NULL;

}

err = git_diff_stats_to_buf(&buf, self->stats, format, width);

if (err < 0)

return Error_set(err);

str = to_unicode_n(buf.ptr, buf.size, NULL, NULL);

git_buf_dispose(&buf);

return str;

}

static void

DiffStats_dealloc(DiffStats *self)

{

git_diff_stats_free(self->stats);

PyObject_Del(self);

}

static PyMethodDef DiffStats_methods[] = {

METHOD(DiffStats, format, METH_VARARGS | METH_KEYWORDS),

{NULL}

};

PyGetSetDef DiffStats_getsetters[] = {

GETTER(DiffStats, insertions),

GETTER(DiffStats, deletions),

GETTER(DiffStats, files_changed),

{NULL}

};

PyDoc_STRVAR(DiffStats__doc__, "DiffStats object.");

PyTypeObject DiffStatsType = {

PyVarObject_HEAD_INIT(NULL, 0)

"_pygit2.DiffStats", /* tp_name */

sizeof(DiffStats), /* tp_basicsize */