PyObject *
Repository_reset(Repository *self, PyObject* args)
{
PyObject *py_oid;
git_oid oid;
git_object *target = NULL;
int err, reset_type;
size_t len;
if (!PyArg_ParseTuple(args, "Oi",
&py_oid,
&reset_type
))
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,
GIT_OBJ_ANY);
err = err < 0 ? err : git_reset(self->repo, target, reset_type, NULL, NULL, NULL);
git_object_free(target);
if (err < 0)
return Error_set_oid(err, &oid, len);
Py_RETURN_NONE;
}
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);
}
static int maybe_sha_or_abbrev(git_object** out, git_repository *repo, const char *spec, size_t speclen)
{
git_oid oid;
if (git_oid_fromstrn(&oid, spec, speclen) < 0)
return GIT_ENOTFOUND;
return git_object_lookup_prefix(out, repo, &oid, speclen, GIT_OBJ_ANY);
}
PyObject *
lookup_object_prefix(Repository *repo, const git_oid *oid, size_t len,
git_otype type)
{
int err;
git_object *obj;
err = git_object_lookup_prefix(&obj, repo->repo, oid,
(unsigned int)len, type);
if (err < 0)
return Error_set_oid(err, oid, len);
return wrap_object(obj, repo);
}
git_tree *resolve_commit_oid_to_tree(
git_repository *repo,
const char *partial_oid)
{
size_t len = strlen(partial_oid);
git_oid oid;
git_object *obj = NULL;
git_tree *tree = NULL;
if (git_oid_fromstrn(&oid, partial_oid, len) == 0)
git_object_lookup_prefix(&obj, repo, &oid, len, GIT_OBJ_ANY);
cl_assert(obj);
if (git_object_type(obj) == GIT_OBJ_TREE)
return (git_tree *)obj;
cl_assert(git_object_type(obj) == GIT_OBJ_COMMIT);
cl_git_pass(git_commit_tree(&tree, (git_commit *)obj));
git_object_free(obj);
return tree;
}
PyObject *
Repository_git_object_lookup_prefix(Repository *self, PyObject *key)
{
int err;
size_t len;
git_oid oid;
git_object *obj;
len = py_oid_to_git_oid(key, &oid);
if (len == 0)
return NULL;
err = git_object_lookup_prefix(&obj, self->repo, &oid, len, GIT_OBJ_ANY);
if (err == 0)
return wrap_object(obj, self);
if (err == GIT_ENOTFOUND)
Py_RETURN_NONE;
return Error_set_oid(err, &oid, len);
}
static void assert_mergebase_many(const char *expected_sha, int count, ...)
{
va_list ap;
int i;
git_oid *oids;
git_oid oid, expected;
char *partial_oid;
git_object *object;
oids = git__malloc(count * sizeof(git_oid));
cl_assert(oids != NULL);
memset(oids, 0x0, count * sizeof(git_oid));
va_start(ap, count);
for (i = 0; i < count; ++i) {
partial_oid = va_arg(ap, char *);
cl_git_pass(git_oid_fromstrn(&oid, partial_oid, strlen(partial_oid)));
cl_git_pass(git_object_lookup_prefix(&object, _repo, &oid, strlen(partial_oid), GIT_OBJ_COMMIT));
git_oid_cpy(&oids[i], git_object_id(object));
git_object_free(object);
}
va_end(ap);
if (expected_sha == NULL)
cl_assert_equal_i(GIT_ENOTFOUND, git_merge_base_many(&oid, _repo, count, oids));
else {
cl_git_pass(git_merge_base_many(&oid, _repo, count, oids));
cl_git_pass(git_oid_fromstr(&expected, expected_sha));
cl_assert(git_oid_cmp(&expected, &oid) == 0);
}
git__free(oids);
}
PyObject *
lookup_object_prefix(Repository *repo, const git_oid *oid, size_t len,
git_otype type)
{
int err;
git_object *obj;
Object *py_obj = NULL;
err = git_object_lookup_prefix(&obj, repo->repo, oid,
(unsigned int)len, type);
if (err < 0)
return Error_set_oid(err, oid, len);
switch (git_object_type(obj)) {
case GIT_OBJ_COMMIT:
py_obj = PyObject_New(Object, &CommitType);
break;
case GIT_OBJ_TREE:
py_obj = PyObject_New(Object, &TreeType);
break;
case GIT_OBJ_BLOB:
py_obj = PyObject_New(Object, &BlobType);
break;
case GIT_OBJ_TAG:
py_obj = PyObject_New(Object, &TagType);
break;
default:
assert(0);
}
if (py_obj) {
py_obj->obj = obj;
py_obj->repo = repo;
Py_INCREF(repo);
}
return (PyObject*)py_obj;
}
int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_otype type) {
return git_object_lookup_prefix(object_out, repo, id, GIT_OID_HEXSZ, type);
}
/**
* Lookup an object in a repository
*
* @param repo S4 class git_repository
* @param hex 4 to 40 char hexadecimal string
* @return S4 object with lookup
*/
SEXP git2r_object_lookup(SEXP repo, SEXP hex)
{
int err;
size_t len;
SEXP result = R_NilValue;
git_object *object = NULL;
git_oid oid;
git_repository *repository = NULL;
if (git2r_error_check_hex_arg(hex))
error("Invalid arguments to git2r_object_lookup");
repository = git2r_repository_open(repo);
if (!repository)
error(git2r_err_invalid_repository);
len = LENGTH(STRING_ELT(hex, 0));
if (GIT_OID_HEXSZ == len) {
git_oid_fromstr(&oid, CHAR(STRING_ELT(hex, 0)));
err = git_object_lookup(&object, repository, &oid, GIT_OBJ_ANY);
if (err < 0)
goto cleanup;
} else {
git_oid_fromstrn(&oid, CHAR(STRING_ELT(hex, 0)), len);
err = git_object_lookup_prefix(&object, repository, &oid, len, GIT_OBJ_ANY);
if (err < 0)
goto cleanup;
}
switch (git_object_type(object)) {
case GIT_OBJ_COMMIT:
PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_commit")));
git2r_commit_init((git_commit*)object, repo, result);
break;
case GIT_OBJ_TREE:
PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_tree")));
git2r_tree_init((git_tree*)object, repo, result);
break;
case GIT_OBJ_BLOB:
PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_blob")));
git2r_blob_init((git_blob*)object, repo, result);
break;
case GIT_OBJ_TAG:
PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_tag")));
git2r_tag_init((git_tag*)object, repo, result);
break;
default:
error("Unimplemented");
}
cleanup:
if (object)
git_object_free(object);
if (repository)
git_repository_free(repository);
if (R_NilValue != result)
UNPROTECT(1);
if (err < 0)
error("Error: %s\n", giterr_last()->message);
return result;
}
int cmd_rev_list(int argc, const char **argv)
{
/* Doesn't pass the tests due to bug in libgit2 apparently */
please_git_do_it_for_me();
const char *commit_string = NULL;
const char *format = NULL;
int i = 0;
git_repository *repository=NULL;
git_oid commit_oid;
git_oid current_oid;
char commit_oid_string[GIT_OID_HEXSZ+1];
size_t len;
int e;
/* For now, we only implement --format=oneline */
if (argc != 3) {
please_git_do_it_for_me();
}
for (i = 1; i < 3; ++i) {
if (*argv[i] == '-') {
if (!prefixcmp(argv[i], "--pretty=")) {
format = argv[i] + strlen("--pretty=");
}
} else {
commit_string = argv[i];
}
}
if (!commit_string) {
/* Show usage : ask git for now */
please_git_do_it_for_me();
}
if (!format) {
/* No option or not handled option */
please_git_do_it_for_me();
}
if (strcmp(format, "oneline")) {
/* Format not supported for now */
please_git_do_it_for_me();
}
/* Supported object specifications are full or short oid */
/* Create the partial oid (filled with '0's) from the given argument */
len = strlen(commit_string);
if (len > GIT_OID_HEXSZ) {
/* It's not a sha1 */
please_git_do_it_for_me();
}
memcpy(commit_oid_string, commit_string, len * sizeof(char));
memset(commit_oid_string + len, '0', (GIT_OID_HEXSZ - len) * sizeof(char));
commit_oid_string[GIT_OID_HEXSZ] = '\0';
e = git_oid_fromstr(&commit_oid, commit_oid_string);
if (e) {
/* Not an OID. The object can be specified in a lot
* of different ways (not supported by libgit2 yet).
* Fall back to git.
*/
please_git_do_it_for_me();
}
repository = get_git_repository();
/* Lookup the commit object */
e = git_object_lookup_prefix((git_object **)&commit, repository, &commit_oid, len, GIT_OBJ_ANY);
if (e != GIT_OK) {
if (e == GIT_ENOTFOUND) {
/* Maybe the given argument is not a sha1
* but a tag name (which looks like a sha1)
* Fall back to git.
*/
please_git_do_it_for_me();
} else if (e == GIT_EAMBIGUOUS) {
error("%s is an ambiguous prefix", commit_string);
} else {
libgit_error();
}
}
if (git_object_type((git_object *)commit) != GIT_OBJ_COMMIT) {
/* Not a commit : nothing to do */
cleanup();
return EXIT_SUCCESS;
}
if (git_revwalk_new(&walk, repository)) {
cleanup();
libgit_error();
}
git_revwalk_sorting(walk, GIT_SORT_TIME);
if (git_revwalk_push(walk, &commit_oid)) {
cleanup();
libgit_error();
}
git_commit_close(commit);
if ((git_revwalk_next(¤t_oid, walk)) == GIT_OK) {
char oid_string[GIT_OID_HEXSZ+1];
oid_string[GIT_OID_HEXSZ] = '\0';
const char *cmsg;
while (1) {
git_oid_fmt(oid_string, ¤t_oid);
if (git_commit_lookup(&commit, repository, ¤t_oid)) {
libgit_error();
}
cmsg = git_commit_message(commit);
git_oid_fmt(oid_string, git_commit_id(commit));
printf("%s %s\n", oid_string, cmsg);
if ((git_revwalk_next(¤t_oid, walk)) != GIT_OK)
break;
git_commit_close(commit);
}
}
cleanup();
return EXIT_SUCCESS;
}
