int git_commit_nth_gen_ancestor(
git_commit **ancestor,
const git_commit *commit,
unsigned int n)
{
git_commit *current, *parent = NULL;
int error;
assert(ancestor && commit);
if (git_object_dup((git_object **) ¤t, (git_object *) commit) < 0)
return -1;
if (n == 0) {
*ancestor = current;
return 0;
}
while (n--) {
error = git_commit_parent(&parent, current, 0);
git_commit_free(current);
if (error < 0)
return error;
current = parent;
}
*ancestor = parent;
return 0;
}
static int dereference_to_non_tag(git_object **out, git_object *obj)
{
if (git_object_type(obj) == GIT_OBJ_TAG)
return git_tag_peel(out, (git_tag *)obj);
return git_object_dup(out, obj);
}
int git_object_peel(
git_object **peeled,
const git_object *object,
git_otype target_type)
{
git_object *source, *deref = NULL;
int error;
assert(object && peeled);
assert(target_type == GIT_OBJ_TAG ||
target_type == GIT_OBJ_COMMIT ||
target_type == GIT_OBJ_TREE ||
target_type == GIT_OBJ_BLOB ||
target_type == GIT_OBJ_ANY);
if ((error = check_type_combination(git_object_type(object), target_type)) < 0)
return peel_error(error, git_object_id(object), target_type);
if (git_object_type(object) == target_type)
return git_object_dup(peeled, (git_object *)object);
source = (git_object *)object;
while (!(error = dereference_object(&deref, source))) {
if (source != object)
git_object_free(source);
if (git_object_type(deref) == target_type) {
*peeled = deref;
return 0;
}
if (target_type == GIT_OBJ_ANY &&
git_object_type(deref) != git_object_type(object))
{
*peeled = deref;
return 0;
}
source = deref;
deref = NULL;
}
if (source != object)
git_object_free(source);
git_object_free(deref);
if (error)
error = peel_error(error, git_object_id(object), target_type);
return error;
}
int git_reference_peel(
git_object **peeled,
git_reference *ref,
git_otype target_type)
{
git_reference *resolved = NULL;
git_object *target = NULL;
int error;
assert(ref);
if (ref->type == GIT_REF_OID) {
resolved = ref;
} else {
if ((error = git_reference_resolve(&resolved, ref)) < 0)
return peel_error(error, ref, "Cannot resolve reference");
}
if (!git_oid_iszero(&resolved->peel)) {
error = git_object_lookup(&target,
git_reference_owner(ref), &resolved->peel, GIT_OBJ_ANY);
} else {
error = git_object_lookup(&target,
git_reference_owner(ref), &resolved->target.oid, GIT_OBJ_ANY);
}
if (error < 0) {
peel_error(error, ref, "Cannot retrieve reference target");
goto cleanup;
}
if (target_type == GIT_OBJ_ANY && git_object_type(target) != GIT_OBJ_TAG)
error = git_object_dup(peeled, target);
else
error = git_object_peel(peeled, target, target_type);
cleanup:
git_object_free(target);
if (resolved != ref)
git_reference_free(resolved);
return error;
}
/**
* Parse the commit options into something we can re-use
*
* Note that parents may be set even when the function errors, so make
* sure to free this data.
*/
static VALUE parse_commit_options(struct commit_data *out, git_repository *repo, VALUE rb_data)
{
VALUE rb_message, rb_tree, rb_parents, rb_ref;
int error = 0, parent_count, i;
rb_ref = rb_hash_aref(rb_data, CSTR2SYM("update_ref"));
if (!NIL_P(rb_ref)) {
Check_Type(rb_ref, T_STRING);
out->update_ref = StringValueCStr(rb_ref);
}
rb_message = rb_hash_aref(rb_data, CSTR2SYM("message"));
Check_Type(rb_message, T_STRING);
out->message = StringValueCStr(rb_message);
out->committer = rugged_signature_get(
rb_hash_aref(rb_data, CSTR2SYM("committer")), repo
);
out->author = rugged_signature_get(
rb_hash_aref(rb_data, CSTR2SYM("author")), repo
);
rb_parents = rb_hash_aref(rb_data, CSTR2SYM("parents"));
Check_Type(rb_parents, T_ARRAY);
rb_tree = rb_hash_aref(rb_data, CSTR2SYM("tree"));
out->tree = (git_tree *)rugged_object_get(repo, rb_tree, GIT_OBJ_TREE);
out->parents = xcalloc(RARRAY_LEN(rb_parents), sizeof(void *));
parent_count = 0;
for (i = 0; i < (int)RARRAY_LEN(rb_parents); ++i) {
VALUE p = rb_ary_entry(rb_parents, i);
git_commit *parent = NULL;
git_commit *tmp = NULL;
if (NIL_P(p))
continue;
if (TYPE(p) == T_STRING) {
git_oid oid;
error = git_oid_fromstr(&oid, StringValueCStr(p));
if (error < GIT_OK)
goto out;
error = git_commit_lookup(&parent, repo, &oid);
if (error < GIT_OK)
goto out;
} else if (rb_obj_is_kind_of(p, rb_cRuggedCommit)) {
Data_Get_Struct(p, git_commit, tmp);
if ((error = git_object_dup((git_object **) &parent, (git_object *) tmp)) < 0)
goto out;
} else {
out->rb_err_obj = rb_exc_new2(rb_eTypeError, "Invalid type for parent object");
error = -1;
goto out;
}
out->parents[parent_count] = parent;
parent_count++;
}
out:
out->parent_count = parent_count;
return error;
}