PyObject *
Branch_upstream_name__get__(Branch *self)
{
int err;
const char *branch_name;
char *c_name = NULL;
PyObject *py_name;
CHECK_REFERENCE(self);
branch_name = git_reference_name(self->reference);
/* Get the length of the upstream name */
err = git_branch_upstream_name(NULL, 0, self->repo->repo, branch_name);
if (err < GIT_OK)
return Error_set(err);
/* Get the actual upstream name */
c_name = calloc(err, sizeof(char));
if (c_name == NULL)
return PyErr_NoMemory();
err = git_branch_upstream_name(c_name,
err * sizeof(char),
self->repo->repo,
branch_name);
if (err < GIT_OK) {
free(c_name);
return Error_set(err);
}
py_name = to_unicode(c_name, NULL, NULL);
free(c_name);
return py_name;
}
PyObject *
Reference_type__get__(Reference *self)
{
git_ref_t c_type;
CHECK_REFERENCE(self);
c_type = git_reference_type(self->reference);
return PyLong_FromLong(c_type);
}
PyObject *
Reference_set_target(Reference *self, PyObject *args, PyObject *kwds)
{
git_oid oid;
char *c_name;
int err;
git_reference *new_ref;
const git_signature *sig = NULL;
PyObject *py_target = NULL;
Signature *py_signature = NULL;
const char *message = NULL;
char *keywords[] = {"target", "signature", "message", NULL};
CHECK_REFERENCE(self);
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O!s", keywords,
&py_target, &SignatureType, &py_signature, &message))
return NULL;
if (py_signature)
sig = py_signature->signature;
/* Case 1: Direct */
if (GIT_REF_OID == git_reference_type(self->reference)) {
err = py_oid_to_git_oid_expand(self->repo->repo, py_target, &oid);
if (err < 0)
goto error;
err = git_reference_set_target(&new_ref, self->reference, &oid, sig, message);
if (err < 0)
goto error;
git_reference_free(self->reference);
self->reference = new_ref;
Py_RETURN_NONE;
}
/* Case 2: Symbolic */
c_name = py_path_to_c_str(py_target);
if (c_name == NULL)
return NULL;
err = git_reference_symbolic_set_target(&new_ref, self->reference, c_name, sig, message);
free(c_name);
if (err < 0)
goto error;
git_reference_free(self->reference);
self->reference = new_ref;
Py_RETURN_NONE;
error:
Error_set(err);
return NULL;
}
PyObject* Branch_branch_name__get__(Branch *self)
{
int err;
const char *c_name;
CHECK_REFERENCE(self);
err = git_branch_name(&c_name, self->reference);
if (err == GIT_OK)
return to_unicode(c_name, NULL, NULL);
else
return Error_set(err);
}
PyObject *
Reference_log(Reference *self)
{
RefLogIter *iter;
CHECK_REFERENCE(self);
iter = PyObject_New(RefLogIter, &RefLogIterType);
if (iter != NULL) {
git_reflog_read(&iter->reflog, self->reference);
iter->size = git_reflog_entrycount(iter->reflog);
iter->i = 0;
}
return (PyObject*)iter;
}
PyObject* Branch_upstream__get__(Branch *self)
{
int err;
git_reference *c_reference;
CHECK_REFERENCE(self);
err = git_branch_upstream(&c_reference, self->reference);
if (err == GIT_ENOTFOUND)
Py_RETURN_NONE;
else if (err < GIT_OK)
return Error_set(err);
return wrap_branch(c_reference, self->repo);
}
PyObject *
Branch_is_head(Branch *self)
{
int err;
CHECK_REFERENCE(self);
err = git_branch_is_head(self->reference);
if (err == 1)
Py_RETURN_TRUE;
else if (err == 0)
Py_RETURN_FALSE;
else
return Error_set(err);
}
PyObject* Branch_rename(Branch *self, PyObject *args)
{
int err, force = 0;
git_reference *c_out;
const char *c_name;
CHECK_REFERENCE(self);
if (!PyArg_ParseTuple(args, "s|i", &c_name, &force))
return NULL;
err = git_branch_move(&c_out, self->reference, c_name, force);
if (err == GIT_OK)
return wrap_branch(c_out, self->repo);
else
return Error_set(err);
}
PyObject *
Reference_delete(Reference *self, PyObject *args)
{
int err;
CHECK_REFERENCE(self);
/* Delete the reference */
err = git_reference_delete(self->reference);
if (err < 0)
return Error_set(err);
git_reference_free(self->reference);
self->reference = NULL; /* Invalidate the pointer */
Py_RETURN_NONE;
}
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 *
Reference_hex__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_py_str(oid);
}
PyObject *
Branch_remote_name__get__(Branch *self)
{
int err;
git_buf name = {NULL};
const char *branch_name;
PyObject *py_name;
CHECK_REFERENCE(self);
branch_name = git_reference_name(self->reference);
err = git_branch_remote_name(&name, self->repo->repo, branch_name);
if (err < GIT_OK)
return Error_set(err);
py_name = to_unicode(name.ptr, NULL, NULL);
git_buf_free(&name);
return py_name;
}
PyObject *
Reference_resolve(Reference *self, PyObject *args)
{
git_reference *c_reference;
int err;
CHECK_REFERENCE(self);
/* Direct: return myself */
if (git_reference_type(self->reference) == GIT_REF_OID) {
Py_INCREF(self);
return (PyObject *)self;
}
/* Symbolic: resolve */
err = git_reference_resolve(&c_reference, self->reference);
if (err < 0)
return Error_set(err);
return wrap_reference(c_reference, self->repo);
}
PyObject *
Reference_target__get__(Reference *self)
{
const char * c_name;
CHECK_REFERENCE(self);
/* Get the target */
if (GIT_REF_OID == git_reference_type(self->reference)) {
return git_oid_to_py_str(git_reference_target(self->reference));
} else {
c_name = git_reference_symbolic_target(self->reference);
if (c_name == NULL) {
PyErr_SetString(PyExc_ValueError, "no target available");
return NULL;
}
}
/* Make a PyString and return it */
return to_path(c_name);
}
PyObject *
Reference_log(Reference *self)
{
int err;
RefLogIter *iter;
git_repository *repo;
CHECK_REFERENCE(self);
repo = git_reference_owner(self->reference);
iter = PyObject_New(RefLogIter, &RefLogIterType);
if (iter != NULL) {
err = git_reflog_read(&iter->reflog, repo, git_reference_name(self->reference));
if (err < 0)
return Error_set(err);
iter->size = git_reflog_entrycount(iter->reflog);
iter->i = 0;
}
return (PyObject*)iter;
}
PyObject *
Reference_peel(Reference *self, PyObject *args)
{
int err, type;
git_object *obj;
PyObject *py_type = Py_None;
CHECK_REFERENCE(self);
if (!PyArg_ParseTuple(args, "|O", &py_type))
return NULL;
type = py_object_to_object_type(py_type);
if (type == -1)
return NULL;
err = git_reference_peel(&obj, self->reference, type);
if (err < 0)
return Error_set(err);
return wrap_object(obj, self->repo);
}
PyObject *
Reference_rename(Reference *self, PyObject *py_name)
{
char *c_name;
int err;
git_reference *new_reference;
CHECK_REFERENCE(self);
/* Get the C name */
c_name = py_path_to_c_str(py_name);
if (c_name == NULL)
return NULL;
/* Rename */
err = git_reference_rename(&new_reference, self->reference, c_name, 0);
git_reference_free(self->reference);
free(c_name);
if (err < 0)
return Error_set(err);
self->reference = new_reference;
Py_RETURN_NONE;
}
PyObject *
Reference_name__get__(Reference *self)
{
CHECK_REFERENCE(self);
return to_path(git_reference_name(self->reference));
}
PyObject *
Reference_shorthand__get__(Reference *self)
{
CHECK_REFERENCE(self);
return to_path(git_reference_shorthand(self->reference));
}
