/*
* call-seq:
* tag.annotation -> annotation or nil
*/
static VALUE rb_git_tag_annotation(VALUE self)
{
git_reference *ref, *resolved_ref;
git_repository *repo;
git_object *target;
int error;
VALUE rb_repo = rugged_owner(self);
rugged_check_repo(rb_repo);
Data_Get_Struct(self, git_reference, ref);
Data_Get_Struct(rb_repo, git_repository, repo);
error = git_reference_resolve(&resolved_ref, ref);
rugged_exception_check(error);
error = git_object_lookup(&target, repo, git_reference_target(resolved_ref), GIT_OBJ_TAG);
git_reference_free(resolved_ref);
if (error == GIT_ENOTFOUND)
return Qnil;
return rugged_object_new(rb_repo, target);
}
/**
* ggit_ref_resolve:
* @ref: a #GgitRef.
* @error: a #GError for error reporting, or %NULL.
*
* Resolves a symbolic reference.
*
* This method iteratively peels a symbolic reference
* until it resolves to a direct reference to an OID.
*
* If a direct reference is passed as an argument,
* that reference is returned immediately.
*
* Returns: (transfer full): the resolved reference to the peeled one.
*/
GgitRef *
ggit_ref_resolve (GgitRef *ref,
GError **error)
{
GgitRef *rev_ref = NULL;
git_reference *reference;
gint ret;
g_return_val_if_fail (ref != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
ret = git_reference_resolve (&reference, _ggit_native_get (ref));
if (ret == GIT_OK)
{
rev_ref = _ggit_ref_wrap (reference, FALSE);
}
else
{
_ggit_error_set (error, ret);
}
return rev_ref;
}
static const char *current_master_tip = "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"; BEGIN_TEST(readsym0, "lookup a symbolic reference") git_repository *repo; git_reference *reference, *resolved_ref; git_object *object; git_oid id; must_pass(git_repository_open(&repo, REPOSITORY_FOLDER)); must_pass(git_reference_lookup(&reference, repo, GIT_HEAD_FILE)); must_be_true(reference->type & GIT_REF_SYMBOLIC); must_be_true((reference->type & GIT_REF_PACKED) == 0); must_be_true(strcmp(reference->name, GIT_HEAD_FILE) == 0); must_pass(git_reference_resolve(&resolved_ref, reference)); must_be_true(resolved_ref->type == GIT_REF_OID); must_pass(git_object_lookup(&object, repo, git_reference_oid(resolved_ref), GIT_OBJ_ANY)); must_be_true(object != NULL); must_be_true(git_object_type(object) == GIT_OBJ_COMMIT); git_oid_fromstr(&id, current_master_tip); must_be_true(git_oid_cmp(&id, git_object_id(object)) == 0); git_object_close(object); git_repository_free(repo); END_TEST BEGIN_TEST(readsym1, "lookup a nested symbolic reference") git_repository *repo;
int cmd_checkout(int argc, const char **argv)
{
/* Delete the following line once gits tests pass
please_git_do_it_for_me();
if (argc != 1)
please_git_do_it_for_me();
*/
git_index *index;
git_repository *repo;
git_index_entry *index_entry;
git_oid id;
/* Open the repository */
if (git_repository_open(&repo, ".git")) {
libgit_error();
}
/* Get the Index file of a Git repository */
if (git_repository_index(&index,repo)) {
libgit_error();
}
/* Find the first index of any entries which point to given path in the Git index */
if (git_index_find (index, ".git")) {
libgit_error();
}
int i = 0;
/* get a pointer to one of the entries in the index */
index_entry = git_index_get(index, i);
if (index_entry == NULL)
printf("Out of bound");
else
id = index_entry->oid;
(void)id;
git_reference *symbolic_ref;
if (git_reference_lookup(&symbolic_ref, repo, "HEAD"))
libgit_error();
git_reference *direct_ref;
if (git_reference_resolve(&direct_ref, symbolic_ref))
libgit_error();
const git_oid *oid;
oid = git_reference_oid(direct_ref);
if (oid == NULL) {
printf("Internal error: reference is not direct\n");
return EXIT_FAILURE;
}
git_tree *tree;
/* Lookup a tree object from the repository */
if (git_tree_lookup(&tree, repo, oid))
libgit_error();
/* Update the index ?? */
if (git_index_read(index))
libgit_error();
git_index_free(index);
git_tree_close(tree);
return EXIT_SUCCESS;
}
int git_commit_create(
git_oid *oid,
git_repository *repo,
const char *update_ref,
const git_signature *author,
const git_signature *committer,
const char *message_encoding,
const char *message,
const git_tree *tree,
int parent_count,
const git_commit *parents[])
{
git_buf commit = GIT_BUF_INIT;
int error, i;
if (git_object_owner((const git_object *)tree) != repo)
return git__throw(GIT_EINVALIDARGS, "The given tree does not belong to this repository");
git_oid__writebuf(&commit, "tree ", git_object_id((const git_object *)tree));
for (i = 0; i < parent_count; ++i) {
if (git_object_owner((const git_object *)parents[i]) != repo) {
error = git__throw(GIT_EINVALIDARGS, "The given parent does not belong to this repository");
goto cleanup;
}
git_oid__writebuf(&commit, "parent ", git_object_id((const git_object *)parents[i]));
}
git_signature__writebuf(&commit, "author ", author);
git_signature__writebuf(&commit, "committer ", committer);
if (message_encoding != NULL)
git_buf_printf(&commit, "encoding %s\n", message_encoding);
git_buf_putc(&commit, '\n');
git_buf_puts(&commit, message);
if (git_buf_oom(&commit)) {
error = git__throw(GIT_ENOMEM, "Not enough memory to build the commit data");
goto cleanup;
}
error = git_odb_write(oid, git_repository_database(repo), commit.ptr, commit.size, GIT_OBJ_COMMIT);
git_buf_free(&commit);
if (error == GIT_SUCCESS && update_ref != NULL) {
git_reference *head;
error = git_reference_lookup(&head, repo, update_ref);
if (error < GIT_SUCCESS)
return git__rethrow(error, "Failed to create commit");
error = git_reference_resolve(&head, head);
if (error < GIT_SUCCESS) {
if (error != GIT_ENOTFOUND)
return git__rethrow(error, "Failed to create commit");
/*
* The target of the reference was not found. This can happen
* just after a repository has been initialized (the master
* branch doesn't exist yet, as it doesn't have anything to
* point to) or after an orphan checkout, so if the target
* branch doesn't exist yet, create it and return.
*/
return git_reference_create_oid(&head, repo, git_reference_target(head), oid, 1);
}
error = git_reference_set_oid(head, oid);
}
if (error < GIT_SUCCESS)
return git__rethrow(error, "Failed to create commit");
return GIT_SUCCESS;
cleanup:
git_buf_free(&commit);
return error;
}
static int add_ref(const char *name, git_repository *repo, git_vector *vec)
{
const char peeled[] = "^{}";
git_remote_head *head;
git_reference *ref;
git_object *obj = NULL;
int error = GIT_SUCCESS, peel_len, ret;
head = git__malloc(sizeof(git_remote_head));
if (head == NULL)
return GIT_ENOMEM;
head->name = git__strdup(name);
if (head->name == NULL) {
error = GIT_ENOMEM;
goto out;
}
error = git_reference_lookup(&ref, repo, name);
if (error < GIT_SUCCESS)
goto out;
error = git_reference_resolve(&ref, ref);
if (error < GIT_SUCCESS)
goto out;
git_oid_cpy(&head->oid, git_reference_oid(ref));
error = git_vector_insert(vec, head);
if (error < GIT_SUCCESS)
goto out;
/* If it's not a tag, we don't need to try to peel it */
if (git__prefixcmp(name, GIT_REFS_TAGS_DIR))
goto out;
error = git_object_lookup(&obj, repo, &head->oid, GIT_OBJ_ANY);
if (error < GIT_SUCCESS) {
git__rethrow(error, "Failed to lookup object");
}
/* If it's not an annotated tag, just get out */
if (git_object_type(obj) != GIT_OBJ_TAG)
goto out;
/* And if it's a tag, peel it, and add it to the list */
head = git__malloc(sizeof(git_remote_head));
peel_len = strlen(name) + STRLEN(peeled);
head->name = git__malloc(peel_len + 1);
ret = snprintf(head->name, peel_len + 1, "%s%s", name, peeled);
if (ret >= peel_len + 1) {
error = git__throw(GIT_ERROR, "The string is magically to long");
}
git_oid_cpy(&head->oid, git_tag_target_oid((git_tag *) obj));
error = git_vector_insert(vec, head);
if (error < GIT_SUCCESS)
goto out;
out:
git_object_close(obj);
if (error < GIT_SUCCESS) {
free(head->name);
free(head);
}
return error;
}
Reference Reference::resolve() const
{
git_reference *ref;
qGitThrow(git_reference_resolve(&ref, d.data()));
return Reference(ref);
}