PyObject *
RefLogIter_iternext(RefLogIter *self)
{
const git_reflog_entry *entry;
RefLogEntry *py_entry;
int err;
if (self->i < self->size) {
entry = git_reflog_entry_byindex(self->reflog, self->i);
py_entry = PyObject_New(RefLogEntry, &RefLogEntryType);
py_entry->oid_old = git_oid_to_python(git_reflog_entry_id_old(entry));
py_entry->oid_new = git_oid_to_python(git_reflog_entry_id_new(entry));
py_entry->message = strdup(git_reflog_entry_message(entry));
err = git_signature_dup(&py_entry->signature,
git_reflog_entry_committer(entry));
if (err < 0)
return Error_set(err);
++(self->i);
return (PyObject*) py_entry;
}
PyErr_SetNone(PyExc_StopIteration);
return NULL;
}
PyObject *
Repository_write(Repository *self, PyObject *args)
{
int err;
git_oid oid;
git_odb *odb;
git_odb_stream* stream;
int type_id;
const char* buffer;
Py_ssize_t buflen;
git_otype type;
if (!PyArg_ParseTuple(args, "Is#", &type_id, &buffer, &buflen))
return NULL;
type = int_to_loose_object_type(type_id);
if (type == GIT_OBJ_BAD)
return PyErr_Format(PyExc_ValueError, "%d", type_id);
err = git_repository_odb(&odb, self->repo);
if (err < 0)
return Error_set(err);
err = git_odb_open_wstream(&stream, odb, buflen, type);
git_odb_free(odb);
if (err < 0)
return Error_set(err);
stream->write(stream, buffer, buflen);
err = stream->finalize_write(&oid, stream);
stream->free(stream);
return git_oid_to_python(oid.id);
}
PyObject *
Repository_create_note(Repository *self, PyObject* args)
{
git_oid note_id, annotated_id;
char *annotated = NULL, *message = NULL, *ref = "refs/notes/commits";
int err = GIT_ERROR;
unsigned int force = 0;
Signature *py_author, *py_committer;
if (!PyArg_ParseTuple(args, "sO!O!s|si",
&message,
&SignatureType, &py_author,
&SignatureType, &py_committer,
&annotated, &ref, &force))
return NULL;
err = git_oid_fromstr(&annotated_id, annotated);
if (err < 0)
return Error_set(err);
err = git_note_create(¬e_id, self->repo, ref, py_author->signature,
py_committer->signature,
&annotated_id, message, force);
if (err < 0)
return Error_set(err);
return git_oid_to_python(¬e_id);
}
PyObject *
Repository_merge_base(Repository *self, PyObject *args)
{
PyObject *value1;
PyObject *value2;
git_oid oid;
git_oid oid1;
git_oid oid2;
int err;
if (!PyArg_ParseTuple(args, "OO", &value1, &value2))
return NULL;
err = py_oid_to_git_oid_expand(self->repo, value1, &oid1);
if (err < 0)
return NULL;
err = py_oid_to_git_oid_expand(self->repo, value2, &oid2);
if (err < 0)
return NULL;
err = git_merge_base(&oid, self->repo, &oid1, &oid2);
if (err < 0)
return Error_set(err);
return git_oid_to_python(&oid);
}
PyObject *
Repository_create_tag(Repository *self, PyObject *args)
{
PyObject *py_oid;
Signature *py_tagger;
char *tag_name, *message;
git_oid oid;
git_object *target = NULL;
int err, target_type;
size_t len;
if (!PyArg_ParseTuple(args, "sOiO!s",
&tag_name,
&py_oid,
&target_type,
&SignatureType, &py_tagger,
&message))
return NULL;
len = py_oid_to_git_oid(py_oid, &oid);
if (len == 0)
return NULL;
err = git_object_lookup_prefix(&target, self->repo, &oid, len,
target_type);
err = err < 0 ? err : git_tag_create(&oid, self->repo, tag_name, target,
py_tagger->signature, message, 0);
git_object_free(target);
if (err < 0)
return Error_set_oid(err, &oid, len);
return git_oid_to_python(&oid);
}
PyObject *
TreeEntry_id__get__(TreeEntry *self)
{
const git_oid *oid;
oid = git_tree_entry_id(self->entry);
return git_oid_to_python(oid);
}
PyObject *
Tag_target__get__(Tag *self)
{
const git_oid *oid;
oid = git_tag_target_id(self->tag);
return git_oid_to_python(oid->id);
}
PyObject *
MergeResult_fastforward_oid__get__(MergeResult *self)
{
if (git_merge_result_is_fastforward(self->result)) {
git_oid fastforward_oid;
git_merge_result_fastforward_oid(&fastforward_oid, self->result);
return git_oid_to_python((const git_oid *)&fastforward_oid);
}
else Py_RETURN_NONE;
}
static int
Repository_build_as_iter(const git_oid *oid, void *accum)
{
int err;
PyObject *py_oid = git_oid_to_python(oid);
err = PyList_Append((PyObject*)accum, py_oid);
Py_DECREF(py_oid);
return err;
}
PyObject *
Object_id__get__(Object *self)
{
const git_oid *oid;
oid = git_object_id(self->obj);
assert(oid);
return git_oid_to_python(oid);
}
PyObject *
TreeBuilder_write(TreeBuilder *self)
{
int err;
git_oid oid;
err = git_treebuilder_write(&oid, self->repo->repo, self->bld);
if (err < 0)
return Error_set(err);
return git_oid_to_python(&oid);
}
PyObject *
Index_write_tree(Index *self)
{
git_oid oid;
int err;
err = git_index_write_tree(&oid, self->index);
if (err < 0)
return Error_set(err);
return git_oid_to_python(oid.id);
}
PyObject *
Repository_expand_id(Repository *self, PyObject *py_hex)
{
git_oid oid;
int err;
err = py_oid_to_git_oid_expand(self->repo, py_hex, &oid);
if (err < 0)
return NULL;
return git_oid_to_python(&oid);
}
PyObject *
Repository_create_blob_fromdisk(Repository *self, PyObject *args)
{
git_oid oid;
const char* path;
int err;
if (!PyArg_ParseTuple(args, "s", &path))
return NULL;
err = git_blob_create_fromdisk(&oid, self->repo, path);
if (err < 0)
return Error_set(err);
return git_oid_to_python(&oid);
}
PyObject *
hashfile(PyObject *self, PyObject *args)
{
git_oid oid;
const char* path;
int err;
if (!PyArg_ParseTuple(args, "s", &path))
return NULL;
err = git_odb_hashfile(&oid, path, GIT_OBJ_BLOB);
if (err < 0)
return Error_set(err);
return git_oid_to_python(&oid);
}
PyObject *
Repository_create_blob(Repository *self, PyObject *args)
{
git_oid oid;
const char *raw;
Py_ssize_t size;
int err;
if (!PyArg_ParseTuple(args, "s#", &raw, &size))
return NULL;
err = git_blob_create_frombuffer(&oid, self->repo, (const void*)raw, size);
if (err < 0)
return Error_set(err);
return git_oid_to_python(&oid);
}
PyObject *
hash(PyObject *self, PyObject *args)
{
git_oid oid;
const char *data;
Py_ssize_t size;
int err;
if (!PyArg_ParseTuple(args, "s#", &data, &size))
return NULL;
err = git_odb_hash(&oid, data, size, GIT_OBJ_BLOB);
if (err < 0) {
return Error_set(err);
}
return git_oid_to_python(&oid);
}
PyObject *
Reference_target__get__(Reference *self)
{
const char * c_name;
CHECK_REFERENCE(self);
/* Case 1: Direct */
if (GIT_REF_OID == git_reference_type(self->reference))
return git_oid_to_python(git_reference_target(self->reference));
/* Case 2: Symbolic */
c_name = git_reference_symbolic_target(self->reference);
if (c_name == NULL) {
PyErr_SetString(PyExc_ValueError, "no target available");
return NULL;
}
return to_path(c_name);
}
PyObject *
Commit_parent_ids__get__(Commit *self)
{
unsigned int i, parent_count;
const git_oid *id;
PyObject *list;
parent_count = git_commit_parentcount(self->commit);
list = PyList_New(parent_count);
if (!list)
return NULL;
for (i=0; i < parent_count; i++) {
id = git_commit_parent_id(self->commit, i);
PyList_SET_ITEM(list, i, git_oid_to_python(id));
}
return list;
}
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);
py_file->path = file->path != NULL ? strdup(file->path) : NULL;
py_file->size = file->size;
py_file->flags = file->flags;
py_file->mode = file->mode;
}
return (PyObject *) py_file;
}
PyObject *
Reference_oid__get__(Reference *self)
{
const git_oid *oid;
CHECK_REFERENCE(self);
/* Get the oid (only for "direct" references) */
oid = git_reference_target(self->reference);
if (oid == NULL) {
PyErr_SetString(PyExc_ValueError,
"oid is only available if the reference is direct "
"(i.e. not symbolic)");
return NULL;
}
/* Convert and return it */
return git_oid_to_python(oid->id);
}
PyObject *
Index_write_tree(Index *self, PyObject *args)
{
git_oid oid;
Repository *repo = NULL;
int err;
if (!PyArg_ParseTuple(args, "|O!", &RepositoryType, &repo))
return NULL;
if (repo)
err = git_index_write_tree_to(&oid, self->index, repo->repo);
else
err = git_index_write_tree(&oid, self->index);
if (err < 0)
return Error_set(err);
return git_oid_to_python(&oid);
}
PyObject *
IndexEntry_get_oid(IndexEntry *self)
{
return git_oid_to_python(self->entry->oid.id);
}
PyObject *
Repository_create_commit(Repository *self, PyObject *args)
{
Signature *py_author, *py_committer;
PyObject *py_oid, *py_message, *py_parents, *py_parent;
PyObject *py_result = NULL;
PyObject *tmessage;
const char *message = NULL;
char *update_ref = NULL;
char *encoding = NULL;
git_oid oid;
git_tree *tree = NULL;
int parent_count;
git_commit **parents = NULL;
int err = 0, i = 0;
size_t len;
if (!PyArg_ParseTuple(args, "zO!O!OOO!|s",
&update_ref,
&SignatureType, &py_author,
&SignatureType, &py_committer,
&py_message,
&py_oid,
&PyList_Type, &py_parents,
&encoding))
return NULL;
len = py_oid_to_git_oid(py_oid, &oid);
if (len == 0)
return NULL;
message = py_str_borrow_c_str(&tmessage, py_message, encoding);
if (message == NULL)
return NULL;
err = git_tree_lookup_prefix(&tree, self->repo, &oid, len);
if (err < 0) {
Error_set(err);
goto out;
}
parent_count = (int)PyList_Size(py_parents);
parents = malloc(parent_count * sizeof(git_commit*));
if (parents == NULL) {
PyErr_SetNone(PyExc_MemoryError);
goto out;
}
for (; i < parent_count; i++) {
py_parent = PyList_GET_ITEM(py_parents, i);
len = py_oid_to_git_oid(py_parent, &oid);
if (len == 0)
goto out;
err = git_commit_lookup_prefix(&parents[i], self->repo, &oid, len);
if (err < 0) {
Error_set(err);
goto out;
}
}
err = git_commit_create(&oid, self->repo, update_ref,
py_author->signature, py_committer->signature,
encoding, message, tree, parent_count,
(const git_commit**)parents);
if (err < 0) {
Error_set(err);
goto out;
}
py_result = git_oid_to_python(&oid);
out:
Py_DECREF(tmessage);
git_tree_free(tree);
while (i > 0) {
i--;
git_commit_free(parents[i]);
}
free(parents);
return py_result;
}
PyObject *
Commit_tree_id__get__(Commit *commit)
{
return git_oid_to_python(git_commit_tree_id(commit->commit));
}
PyObject *
IndexEntry_oid__get__(IndexEntry *self)
{
return git_oid_to_python(&self->entry.oid);
}
PyObject *
Note_oid__get__(Note *self)
{
return git_oid_to_python(git_note_oid(self->note));
}
