proxmox-mirrors/libgit2
1
0
Fork 0
mirror of https://git.proxmox.com/git/libgit2 synced 2025-08-04 18:56:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Change the object creation/lookup API

Browse Source 
The methods previously known as

	git_repository_lookup
	git_repository_newobject
	git_repository_lookup_ref

are now part of their respective namespaces:

	git_object_lookup
	git_object_new
	git_reference_lookup

This makes the API more consistent with the new references API.

Signed-off-by: Vicent Marti <tanoku@gmail.com>
This commit is contained in:
Vicent Marti 2011-02-28 12:12:26 +02:00
parent 3dccfed163
commit 5de079b86d
14 changed files with 233 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/commit.c
View File

@ -121,7 +121,7 @@ int commit_parse_buffer(git_commit *commit, void *data, size_t len, unsigned int
if ((error = git__parse_oid(&oid, &buffer, buffer_end, "tree ")) < GIT_SUCCESS)
return error;
if ((error = git_repository_lookup((git_object **)&commit->tree, commit->object.repo, &oid, GIT_OBJ_TREE)) < GIT_SUCCESS)
if ((error = git_object_lookup((git_object **)&commit->tree, commit->object.repo, &oid, GIT_OBJ_TREE)) < GIT_SUCCESS)
return error;
/*
@ -131,7 +131,7 @@ int commit_parse_buffer(git_commit *commit, void *data, size_t len, unsigned int
while (git__parse_oid(&oid, &buffer, buffer_end, "parent ") == GIT_SUCCESS) {
git_commit *parent;
if ((error = git_repository_lookup((git_object **)&parent, commit->object.repo, &oid, GIT_OBJ_COMMIT)) < GIT_SUCCESS)
if ((error = git_object_lookup((git_object **)&parent, commit->object.repo, &oid, GIT_OBJ_COMMIT)) < GIT_SUCCESS)
return error;
if (git_vector_insert(&commit->parents, parent) < GIT_SUCCESS)

6
src/git2/blob.h
View File

@ -28,7 +28,7 @@
#include "common.h"
#include "types.h"
#include "oid.h"
#include "repository.h"
#include "object.h"
/**
* @file git2/blob.h
@ -51,7 +51,7 @@ GIT_BEGIN_DECL
*/
GIT_INLINE(int) git_blob_lookup(git_blob **blob, git_repository *repo, const git_oid *id)
{
return git_repository_lookup((git_object **)blob, repo, id, GIT_OBJ_BLOB);
return git_object_lookup((git_object **)blob, repo, id, GIT_OBJ_BLOB);
}
/**
@ -67,7 +67,7 @@ GIT_INLINE(int) git_blob_lookup(git_blob **blob, git_repository *repo, const git
*/
GIT_INLINE(int) git_blob_new(git_blob **blob, git_repository *repo)
{
return git_repository_newobject((git_object **)blob, repo, GIT_OBJ_BLOB);
return git_object_new((git_object **)blob, repo, GIT_OBJ_BLOB);
}
/**

6
src/git2/commit.h
View File

@ -28,7 +28,7 @@
#include "common.h"
#include "types.h"
#include "oid.h"
#include "repository.h"
#include "object.h"
/**
* @file git2/commit.h
@ -52,7 +52,7 @@ GIT_BEGIN_DECL
*/
GIT_INLINE(int) git_commit_lookup(git_commit **commit, git_repository *repo, const git_oid *id)
{
return git_repository_lookup((git_object **)commit, repo, id, GIT_OBJ_COMMIT);
return git_object_lookup((git_object **)commit, repo, id, GIT_OBJ_COMMIT);
}
/**
@ -68,7 +68,7 @@ GIT_INLINE(int) git_commit_lookup(git_commit **commit, git_repository *repo, con
*/
GIT_INLINE(int) git_commit_new(git_commit **commit, git_repository *repo)
{
return git_repository_newobject((git_object **)commit, repo, GIT_OBJ_COMMIT);
return git_object_new((git_object **)commit, repo, GIT_OBJ_COMMIT);
}
/**

43
src/git2/object.h
View File

@ -38,6 +38,49 @@
*/
GIT_BEGIN_DECL
/**
* Lookup a reference to one of the objects in a repostory.
*
* The generated reference is owned by the repository and
* should not be freed by the user.
*
* The 'type' parameter must match the type of the object
* in the odb; the method will fail otherwise.
* The special value 'GIT_OBJ_ANY' may be passed to let
* the method guess the object's type.
*
* @param object pointer to the looked-up object
* @param repo the repository to look up the object
* @param id the unique identifier for the object
* @param type the type of the object
* @return a reference to the object
*/
GIT_EXTERN(int) git_object_lookup(git_object **object, git_repository *repo, const git_oid *id, git_otype type);
/**
* Create a new in-memory repository object with
* the given type.
*
* The object's attributes can be filled in using the
* corresponding setter methods.
*
* The object will be written back to given git_repository
* when the git_object_write() function is called; objects
* cannot be written to disk until all their main
* attributes have been properly filled.
*
* Objects are instantiated with no SHA1 id; their id
* will be automatically generated when writing to the
* repository.
*
* @param object pointer to the new object
* @parem repo Repository where the object belongs
* @param type Type of the object to be created
* @return the new object
*/
GIT_EXTERN(int) git_object_new(git_object **object, git_repository *repo, git_otype type);
/**
* Write back an object to disk.
*

13
src/git2/refs.h
View File

@ -38,6 +38,19 @@
*/
GIT_BEGIN_DECL
/**
* Lookup a reference by its name in a repository.
*
* The generated reference is owned by the repository and
* should not be freed by the user.
*
* @param reference_out pointer to the looked-up reference
* @param repo the repository to look up the reference
* @param name the long name for the reference (e.g. HEAD, ref/heads/master, refs/tags/v0.1.0, ...)
* @return 0 on success; error code otherwise
*/
GIT_EXTERN(int) git_reference_lookup(git_reference **reference_out, git_repository *repo, const char *name);
/**
* Create a new symbolic reference.
*

59
src/git2/repository.h
View File

@ -132,26 +132,6 @@ GIT_EXTERN(int) git_repository_open3(git_repository **repository,
const char *git_index_file,
const char *git_work_tree);
/**
* Lookup a reference to one of the objects in the repostory.
*
* The generated reference is owned by the repository and
* should not be freed by the user.
*
* The 'type' parameter must match the type of the object
* in the odb; the method will fail otherwise.
* The special value 'GIT_OBJ_ANY' may be passed to let
* the method guess the object's type.
*
* @param object pointer to the looked-up object
* @param repo the repository to look up the object
* @param id the unique identifier for the object
* @param type the type of the object
* @return a reference to the object
*/
GIT_EXTERN(int) git_repository_lookup(git_object **object, git_repository *repo, const git_oid *id, git_otype type);
/**
* Get the object database behind a Git repository
*
@ -172,29 +152,6 @@ GIT_EXTERN(git_odb *) git_repository_database(git_repository *repo);
*/
GIT_EXTERN(int) git_repository_index(git_index **index, git_repository *repo);
/**
* Create a new in-memory repository object with
* the given type.
*
* The object's attributes can be filled in using the
* corresponding setter methods.
*
* The object will be written back to given git_repository
* when the git_object_write() function is called; objects
* cannot be written to disk until all their main
* attributes have been properly filled.
*
* Objects are instantiated with no SHA1 id; their id
* will be automatically generated when writing to the
* repository.
*
* @param object pointer to the new object
* @parem repo Repository where the object belongs
* @param type Type of the object to be created
* @return the new object
*/
GIT_EXTERN(int) git_repository_newobject(git_object **object, git_repository *repo, git_otype type);
/**
* Free a previously allocated repository
* @param repo repository handle to close. If NULL nothing occurs.
@ -218,22 +175,6 @@ GIT_EXTERN(void) git_repository_free(git_repository *repo);
*/
GIT_EXTERN(int) git_repository_init(git_repository **repo_out, const char *path, unsigned is_bare);
/**
* Lookup a reference by its name in the repository.
*
* The generated reference is owned by the repository and
* should not be freed by the user.
*
* TODO:
* - Ensure the reference name is valid
*
* @param reference_out pointer to the looked-up reference
* @param repo the repository to look up the reference
* @param name the long name for the reference (e.g. HEAD, ref/heads/master, refs/tags/v0.1.0, ...)
* @return a reference to the reference
*/
GIT_EXTERN(int) git_repository_lookup_ref(git_reference **reference_out, git_repository *repo, const char *name);
/** @} */
GIT_END_DECL
#endif

6
src/git2/tag.h
View File

@ -28,7 +28,7 @@
#include "common.h"
#include "types.h"
#include "oid.h"
#include "repository.h"
#include "object.h"
/**
* @file git2/tag.h
@ -51,7 +51,7 @@ GIT_BEGIN_DECL
*/
GIT_INLINE(int) git_tag_lookup(git_tag **tag, git_repository *repo, const git_oid *id)
{
return git_repository_lookup((git_object **)tag, repo, id, (git_otype)GIT_OBJ_TAG);
return git_object_lookup((git_object **)tag, repo, id, (git_otype)GIT_OBJ_TAG);
}
/**
@ -67,7 +67,7 @@ GIT_INLINE(int) git_tag_lookup(git_tag **tag, git_repository *repo, const git_oi
*/
GIT_INLINE(int) git_tag_new(git_tag **tag, git_repository *repo)
{
return git_repository_newobject((git_object **)tag, repo, (git_otype)GIT_OBJ_TAG);
return git_object_new((git_object **)tag, repo, (git_otype)GIT_OBJ_TAG);
}
/**

6
src/git2/tree.h
View File

@ -28,7 +28,7 @@
#include "common.h"
#include "types.h"
#include "oid.h"
#include "repository.h"
#include "object.h"
/**
* @file git2/tree.h
@ -51,7 +51,7 @@ GIT_BEGIN_DECL
*/
GIT_INLINE(int) git_tree_lookup(git_tree **tree, git_repository *repo, const git_oid *id)
{
return git_repository_lookup((git_object **)tree, repo, id, GIT_OBJ_TREE);
return git_object_lookup((git_object **)tree, repo, id, GIT_OBJ_TREE);
}
/**
@ -67,7 +67,7 @@ GIT_INLINE(int) git_tree_lookup(git_tree **tree, git_repository *repo, const git
*/
GIT_INLINE(int) git_tree_new(git_tree **tree, git_repository *repo)
{
return git_repository_newobject((git_object **)tree, repo, GIT_OBJ_TREE);
return git_object_new((git_object **)tree, repo, GIT_OBJ_TREE);
}
/**

119
src/object.c
View File

@ -209,6 +209,125 @@ void git_object__source_close(git_object *object)
}
}
static int create_object(git_object **object_out, git_otype type)
{
git_object *object = NULL;
assert(object_out);
*object_out = NULL;
switch (type) {
case GIT_OBJ_COMMIT:
case GIT_OBJ_TAG:
case GIT_OBJ_BLOB:
object = git__malloc(git_object__size(type));
if (object == NULL)
return GIT_ENOMEM;
memset(object, 0x0, git_object__size(type));
break;
case GIT_OBJ_TREE:
object = (git_object *)git_tree__new();
if (object == NULL)
return GIT_ENOMEM;
break;
default:
return GIT_EINVALIDTYPE;
}
*object_out = object;
return GIT_SUCCESS;
}
int git_object_new(git_object **object_out, git_repository *repo, git_otype type)
{
git_object *object = NULL;
int error;
assert(object_out && repo);
if ((error = create_object(&object, type)) < GIT_SUCCESS)
return error;
object->repo = repo;
object->in_memory = 1;
object->modified = 1;
object->source.raw.type = type;
*object_out = object;
return GIT_SUCCESS;
}
int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_otype type)
{
git_object *object = NULL;
git_rawobj obj_file;
int error = GIT_SUCCESS;
assert(repo && object_out && id);
object = git_hashtable_lookup(repo->objects, id);
if (object != NULL) {
*object_out = object;
return GIT_SUCCESS;
}
error = git_odb_read(&obj_file, repo->db, id);
if (error < GIT_SUCCESS)
return error;
if (type != GIT_OBJ_ANY && type != obj_file.type) {
git_rawobj_close(&obj_file);
return GIT_EINVALIDTYPE;
}
type = obj_file.type;
if ((error = create_object(&object, type)) < GIT_SUCCESS)
return error;
/* Initialize parent object */
git_oid_cpy(&object->id, id);
object->repo = repo;
memcpy(&object->source.raw, &obj_file, sizeof(git_rawobj));
object->source.open = 1;
switch (type) {
case GIT_OBJ_COMMIT:
error = git_commit__parse((git_commit *)object);
break;
case GIT_OBJ_TREE:
error = git_tree__parse((git_tree *)object);
break;
case GIT_OBJ_TAG:
error = git_tag__parse((git_tag *)object);
break;
case GIT_OBJ_BLOB:
error = git_blob__parse((git_blob *)object);
break;
default:
break;
}
if (error < GIT_SUCCESS) {
git_object_free(object);
return error;
}
git_object__source_close(object);
git_hashtable_insert(repo->objects, &object->id, object);
*object_out = object;
return GIT_SUCCESS;
}
int git_object_write(git_object *object)
{
int error;

8
src/refs.c
View File

@ -818,7 +818,7 @@ cleanup:
/**
* Constructors
*/
int git_repository_lookup_ref(git_reference **ref_out, git_repository *repo, const char *name)
int git_reference_lookup(git_reference **ref_out, git_repository *repo, const char *name)
{
int error;
char normalized_name[GIT_PATH_MAX];
@ -1118,7 +1118,7 @@ int git_reference_delete(git_reference *ref)
/* When deleting a loose reference, we have to ensure that an older
* packed version of it doesn't exist
*/
if (!git_repository_lookup_ref(&reference, ref->owner, ref->name)) {
if (!git_reference_lookup(&reference, ref->owner, ref->name)) {
assert((reference->type & GIT_REF_PACKED) != 0);
error = git_reference_delete(reference);
}
@ -1157,7 +1157,7 @@ int git_reference_rename(git_reference *ref, const char *new_name)
return error;
/* Ensure we're not going to overwrite an existing reference */
error = git_repository_lookup_ref(&looked_up_ref, ref->owner, new_name);
error = git_reference_lookup(&looked_up_ref, ref->owner, new_name);
if (error == GIT_SUCCESS)
return GIT_EINVALIDREFNAME;
@ -1269,7 +1269,7 @@ int git_reference_resolve(git_reference **resolved_ref, git_reference *ref)
}
ref_sym = (reference_symbolic *)ref;
if ((error = git_repository_lookup_ref(&ref, repo, ref_sym->target)) < GIT_SUCCESS)
if ((error = git_reference_lookup(&ref, repo, ref_sym->target)) < GIT_SUCCESS)
return error;
}

119
src/repository.c
View File

@ -379,125 +379,6 @@ git_odb *git_repository_database(git_repository *repo)
return repo->db;
}
static int create_object(git_object **object_out, git_otype type)
{
git_object *object = NULL;
assert(object_out);
*object_out = NULL;
switch (type) {
case GIT_OBJ_COMMIT:
case GIT_OBJ_TAG:
case GIT_OBJ_BLOB:
object = git__malloc(git_object__size(type));
if (object == NULL)
return GIT_ENOMEM;
memset(object, 0x0, git_object__size(type));
break;
case GIT_OBJ_TREE:
object = (git_object *)git_tree__new();
if (object == NULL)
return GIT_ENOMEM;
break;
default:
return GIT_EINVALIDTYPE;
}
*object_out = object;
return GIT_SUCCESS;
}
int git_repository_newobject(git_object **object_out, git_repository *repo, git_otype type)
{
git_object *object = NULL;
int error;
assert(object_out && repo);
if ((error = create_object(&object, type)) < GIT_SUCCESS)
return error;
object->repo = repo;
object->in_memory = 1;
object->modified = 1;
object->source.raw.type = type;
*object_out = object;
return GIT_SUCCESS;
}
int git_repository_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_otype type)
{
git_object *object = NULL;
git_rawobj obj_file;
int error = GIT_SUCCESS;
assert(repo && object_out && id);
object = git_hashtable_lookup(repo->objects, id);
if (object != NULL) {
*object_out = object;
return GIT_SUCCESS;
}
error = git_odb_read(&obj_file, repo->db, id);
if (error < GIT_SUCCESS)
return error;
if (type != GIT_OBJ_ANY && type != obj_file.type) {
git_rawobj_close(&obj_file);
return GIT_EINVALIDTYPE;
}
type = obj_file.type;
if ((error = create_object(&object, type)) < GIT_SUCCESS)
return error;
/* Initialize parent object */
git_oid_cpy(&object->id, id);
object->repo = repo;
memcpy(&object->source.raw, &obj_file, sizeof(git_rawobj));
object->source.open = 1;
switch (type) {
case GIT_OBJ_COMMIT:
error = git_commit__parse((git_commit *)object);
break;
case GIT_OBJ_TREE:
error = git_tree__parse((git_tree *)object);
break;
case GIT_OBJ_TAG:
error = git_tag__parse((git_tag *)object);
break;
case GIT_OBJ_BLOB:
error = git_blob__parse((git_blob *)object);
break;
default:
break;
}
if (error < GIT_SUCCESS) {
git_object_free(object);
return error;
}
git_object__source_close(object);
git_hashtable_insert(repo->objects, &object->id, object);
*object_out = object;
return GIT_SUCCESS;
}
static int repo_init_reinit(repo_init *results)
{
/* TODO: reinit the repository */

2
src/tag.c
View File

@ -164,7 +164,7 @@ static int parse_tag_buffer(git_tag *tag, char *buffer, const char *buffer_end)
if (tag->type == GIT_OBJ_BAD)
return GIT_EOBJCORRUPTED;
error = git_repository_lookup(&tag->target, tag->object.repo, &target_oid, tag->type);
error = git_object_lookup(&tag->target, tag->object.repo, &target_oid, tag->type);
if (error < 0)
return error;

2
src/tree.c
View File

@ -153,7 +153,7 @@ const git_oid *git_tree_entry_id(git_tree_entry *entry)
int git_tree_entry_2object(git_object **object_out, git_tree_entry *entry)
{
assert(entry && object_out);
return git_repository_lookup(object_out, entry->owner->object.repo, &entry->oid, GIT_OBJ_ANY);
return git_object_lookup(object_out, entry->owner->object.repo, &entry->oid, GIT_OBJ_ANY);
}
static void sort_entries(git_tree *tree)

76
tests/t10-refs.c
View File

@ -37,12 +37,12 @@ BEGIN_TEST(readtag0, "lookup a loose tag reference")
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_pass(git_repository_lookup_ref(&reference, repo, loose_tag_ref_name));
must_pass(git_reference_lookup(&reference, repo, loose_tag_ref_name));
must_be_true(reference->type & GIT_REF_OID);
must_be_true((reference->type & GIT_REF_PACKED) == 0);
must_be_true(strcmp(reference->name, loose_tag_ref_name) == 0);
must_pass(git_repository_lookup(&object, repo, git_reference_oid(reference), GIT_OBJ_ANY));
must_pass(git_object_lookup(&object, repo, git_reference_oid(reference), GIT_OBJ_ANY));
must_be_true(object != NULL);
must_be_true(git_object_type(object) == GIT_OBJ_TAG);
@ -54,7 +54,7 @@ BEGIN_TEST(readtag1, "lookup a loose tag reference that doesn't exist")
git_reference *reference;
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_fail(git_repository_lookup_ref(&reference, repo, non_existing_tag_ref_name));
must_fail(git_reference_lookup(&reference, repo, non_existing_tag_ref_name));
git_repository_free(repo);
END_TEST
@ -71,7 +71,7 @@ BEGIN_TEST(readsym0, "lookup a symbolic reference")
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_pass(git_repository_lookup_ref(&reference, repo, GIT_HEAD_FILE));
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);
@ -79,7 +79,7 @@ BEGIN_TEST(readsym0, "lookup a symbolic reference")
must_pass(git_reference_resolve(&resolved_ref, reference));
must_be_true(resolved_ref->type == GIT_REF_OID);
must_pass(git_repository_lookup(&object, repo, git_reference_oid(resolved_ref), GIT_OBJ_ANY));
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);
@ -97,7 +97,7 @@ BEGIN_TEST(readsym1, "lookup a nested symbolic reference")
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_pass(git_repository_lookup_ref(&reference, repo, head_tracker_sym_ref_name));
must_pass(git_reference_lookup(&reference, repo, head_tracker_sym_ref_name));
must_be_true(reference->type & GIT_REF_SYMBOLIC);
must_be_true((reference->type & GIT_REF_PACKED) == 0);
must_be_true(strcmp(reference->name, head_tracker_sym_ref_name) == 0);
@ -105,7 +105,7 @@ BEGIN_TEST(readsym1, "lookup a nested symbolic reference")
must_pass(git_reference_resolve(&resolved_ref, reference));
must_be_true(resolved_ref->type == GIT_REF_OID);
must_pass(git_repository_lookup(&object, repo, git_reference_oid(resolved_ref), GIT_OBJ_ANY));
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);
@ -121,15 +121,15 @@ BEGIN_TEST(readsym2, "lookup the HEAD and resolve the master branch")
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_pass(git_repository_lookup_ref(&reference, repo, head_tracker_sym_ref_name));
must_pass(git_reference_lookup(&reference, repo, head_tracker_sym_ref_name));
must_pass(git_reference_resolve(&resolved_ref, reference));
comp_base_ref = resolved_ref;
must_pass(git_repository_lookup_ref(&reference, repo, GIT_HEAD_FILE));
must_pass(git_reference_lookup(&reference, repo, GIT_HEAD_FILE));
must_pass(git_reference_resolve(&resolved_ref, reference));
must_pass(git_oid_cmp(git_reference_oid(comp_base_ref), git_reference_oid(resolved_ref)));
must_pass(git_repository_lookup_ref(&reference, repo, current_head_target));
must_pass(git_reference_lookup(&reference, repo, current_head_target));
must_pass(git_reference_resolve(&resolved_ref, reference));
must_pass(git_oid_cmp(git_reference_oid(comp_base_ref), git_reference_oid(resolved_ref)));
@ -142,8 +142,8 @@ BEGIN_TEST(readsym3, "lookup the master branch and then the HEAD")
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_pass(git_repository_lookup_ref(&master_ref, repo, current_head_target));
must_pass(git_repository_lookup_ref(&reference, repo, GIT_HEAD_FILE));
must_pass(git_reference_lookup(&master_ref, repo, current_head_target));
must_pass(git_reference_lookup(&reference, repo, GIT_HEAD_FILE));
must_pass(git_reference_resolve(&resolved_ref, reference));
must_pass(git_oid_cmp(git_reference_oid(master_ref), git_reference_oid(resolved_ref)));
@ -161,12 +161,12 @@ BEGIN_TEST(readpacked0, "lookup a packed reference")
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_pass(git_repository_lookup_ref(&reference, repo, packed_head_name));
must_pass(git_reference_lookup(&reference, repo, packed_head_name));
must_be_true(reference->type & GIT_REF_OID);
must_be_true((reference->type & GIT_REF_PACKED) != 0);
must_be_true(strcmp(reference->name, packed_head_name) == 0);
must_pass(git_repository_lookup(&object, repo, git_reference_oid(reference), GIT_OBJ_ANY));
must_pass(git_object_lookup(&object, repo, git_reference_oid(reference), GIT_OBJ_ANY));
must_be_true(object != NULL);
must_be_true(git_object_type(object) == GIT_OBJ_COMMIT);
@ -178,8 +178,8 @@ BEGIN_TEST(readpacked1, "assure that a loose reference is looked up before a pac
git_reference *reference;
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_pass(git_repository_lookup_ref(&reference, repo, packed_head_name));
must_pass(git_repository_lookup_ref(&reference, repo, packed_test_head_name));
must_pass(git_reference_lookup(&reference, repo, packed_head_name));
must_pass(git_reference_lookup(&reference, repo, packed_test_head_name));
must_be_true(reference->type & GIT_REF_OID);
must_be_true((reference->type & GIT_REF_PACKED) == 0);
must_be_true(strcmp(reference->name, packed_test_head_name) == 0);
@ -206,7 +206,7 @@ BEGIN_TEST(create0, "create a new symbolic reference")
must_pass(git_reference_create_symbolic(&new_reference, repo, new_head_tracker, current_head_target));
/* Ensure the reference can be looked-up... */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, new_head_tracker));
must_pass(git_reference_lookup(&looked_up_ref, repo, new_head_tracker));
must_be_true(looked_up_ref->type & GIT_REF_SYMBOLIC);
must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
must_be_true(strcmp(looked_up_ref->name, new_head_tracker) == 0);
@ -223,7 +223,7 @@ BEGIN_TEST(create0, "create a new symbolic reference")
/* Similar test with a fresh new repository */
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, new_head_tracker));
must_pass(git_reference_lookup(&looked_up_ref, repo, new_head_tracker));
must_pass(git_reference_resolve(&resolved_ref, looked_up_ref));
must_be_true(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0);
@ -246,7 +246,7 @@ BEGIN_TEST(create1, "create a deep symbolic reference")
git__joinpath(ref_path, repo->path_repository, new_head_tracker);
must_pass(git_reference_create_symbolic(&new_reference, repo, new_head_tracker, current_head_target));
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, new_head_tracker));
must_pass(git_reference_lookup(&looked_up_ref, repo, new_head_tracker));
must_pass(git_reference_resolve(&resolved_ref, looked_up_ref));
must_be_true(git_oid_cmp(&id, git_reference_oid(resolved_ref)) == 0);
@ -274,7 +274,7 @@ BEGIN_TEST(create2, "create a new OID reference")
must_pass(git_reference_create_oid(&new_reference, repo, new_head, &id));
/* Ensure the reference can be looked-up... */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, new_head));
must_pass(git_reference_lookup(&looked_up_ref, repo, new_head));
must_be_true(looked_up_ref->type & GIT_REF_OID);
must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
must_be_true(strcmp(looked_up_ref->name, new_head) == 0);
@ -287,7 +287,7 @@ BEGIN_TEST(create2, "create a new OID reference")
/* Similar test with a fresh new repository */
must_pass(git_repository_open(&repo, REPOSITORY_FOLDER));
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, new_head));
must_pass(git_reference_lookup(&looked_up_ref, repo, new_head));
must_be_true(git_oid_cmp(&id, git_reference_oid(looked_up_ref)) == 0);
git_repository_free(repo);
@ -318,7 +318,7 @@ BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo")
must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
/* Ensure a known loose ref can be looked up */
must_pass(git_repository_lookup_ref(&reference, repo, loose_tag_ref_name));
must_pass(git_reference_lookup(&reference, repo, loose_tag_ref_name));
must_be_true((reference->type & GIT_REF_PACKED) == 0);
must_be_true(strcmp(reference->name, loose_tag_ref_name) == 0);
@ -329,7 +329,7 @@ BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo")
must_pass(gitfo_exists(temp_path));
/* Ensure the known ref can still be looked up but is now packed */
must_pass(git_repository_lookup_ref(&reference, repo, loose_tag_ref_name));
must_pass(git_reference_lookup(&reference, repo, loose_tag_ref_name));
must_be_true((reference->type & GIT_REF_PACKED) != 0);
must_be_true(strcmp(reference->name, loose_tag_ref_name) == 0);
@ -353,7 +353,7 @@ BEGIN_TEST(rename0, "rename a loose reference")
must_pass(!gitfo_exists(temp_path));
/* Retrieval of the reference to rename */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, loose_tag_ref_name));
must_pass(git_reference_lookup(&looked_up_ref, repo, loose_tag_ref_name));
/* ... which is indeed loose */
must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
@ -363,10 +363,10 @@ BEGIN_TEST(rename0, "rename a loose reference")
must_be_true(!strcmp(looked_up_ref->name, new_name));
/* ...It can't be looked-up with the old name... */
must_fail(git_repository_lookup_ref(&another_looked_up_ref, repo, loose_tag_ref_name));
must_fail(git_reference_lookup(&another_looked_up_ref, repo, loose_tag_ref_name));
/* ...but the new name works ok... */
must_pass(git_repository_lookup_ref(&another_looked_up_ref, repo, new_name));
must_pass(git_reference_lookup(&another_looked_up_ref, repo, new_name));
must_be_true(!strcmp(another_looked_up_ref->name, new_name));
/* .. the ref is still loose... */
@ -393,7 +393,7 @@ BEGIN_TEST(rename1, "rename a packed reference (should make it loose)")
must_pass(!gitfo_exists(temp_path));
/* The reference can however be looked-up... */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, packed_head_name));
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
/* .. and it's packed */
must_be_true((looked_up_ref->type & GIT_REF_PACKED) != 0);
@ -403,10 +403,10 @@ BEGIN_TEST(rename1, "rename a packed reference (should make it loose)")
must_be_true(!strcmp(looked_up_ref->name, brand_new_name));
/* ...It can't be looked-up with the old name... */
must_fail(git_repository_lookup_ref(&another_looked_up_ref, repo, packed_head_name));
must_fail(git_reference_lookup(&another_looked_up_ref, repo, packed_head_name));
/* ...but the new name works ok... */
must_pass(git_repository_lookup_ref(&another_looked_up_ref, repo, brand_new_name));
must_pass(git_reference_lookup(&another_looked_up_ref, repo, brand_new_name));
must_be_true(!strcmp(another_looked_up_ref->name, brand_new_name));
/* .. the ref is no longer packed... */
@ -433,13 +433,13 @@ BEGIN_TEST(rename2, "renaming a packed reference does not pack another reference
must_pass(gitfo_exists(temp_path));
/* Lookup the other reference */
must_pass(git_repository_lookup_ref(&another_looked_up_ref, repo, packed_test_head_name));
must_pass(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
/* Ensure it's loose */
must_be_true((another_looked_up_ref->type & GIT_REF_PACKED) == 0);
/* Lookup the reference to rename */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, packed_head_name));
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
/* Ensure it's packed */
must_be_true((looked_up_ref->type & GIT_REF_PACKED) != 0);
@ -448,7 +448,7 @@ BEGIN_TEST(rename2, "renaming a packed reference does not pack another reference
must_pass(git_reference_rename(looked_up_ref, brand_new_name));
/* Lookup the other reference */
must_pass(git_repository_lookup_ref(&another_looked_up_ref, repo, packed_test_head_name));
must_pass(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
/* Ensure it's loose */
must_be_true((another_looked_up_ref->type & GIT_REF_PACKED) == 0);
@ -466,13 +466,13 @@ BEGIN_TEST(rename3, "can not rename a reference with the name of an existing ref
must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
/* An existing reference... */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, packed_head_name));
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
/* Can not be renamed to the name of another existing reference. */
must_fail(git_reference_rename(looked_up_ref, packed_test_head_name));
/* Failure to rename it hasn't corrupted its state */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, packed_head_name));
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
must_be_true(!strcmp(looked_up_ref->name, packed_head_name));
close_temp_repo(repo);
@ -485,7 +485,7 @@ BEGIN_TEST(rename4, "can not rename a reference with an invalid name")
must_pass(open_temp_repo(&repo, REPOSITORY_FOLDER));
/* An existing oid reference... */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, packed_test_head_name));
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_test_head_name));
/* Can not be renamed with an invalid name. */
must_fail(git_reference_rename(looked_up_ref, "Hello! I'm a very invalid name."));
@ -494,7 +494,7 @@ BEGIN_TEST(rename4, "can not rename a reference with an invalid name")
must_fail(git_reference_rename(looked_up_ref, "i-will-sudo-you"));
/* Failure to rename it hasn't corrupted its state */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, packed_test_head_name));
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_test_head_name));
must_be_true(!strcmp(looked_up_ref->name, packed_test_head_name));
close_temp_repo(repo);
@ -512,7 +512,7 @@ BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove
must_pass(gitfo_exists(temp_path));
/* Lookup the reference */
must_pass(git_repository_lookup_ref(&looked_up_ref, repo, packed_test_head_name));
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_test_head_name));
/* Ensure it's the loose version that has been found */
must_be_true((looked_up_ref->type & GIT_REF_PACKED) == 0);
@ -521,7 +521,7 @@ BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove
must_pass(git_reference_delete(looked_up_ref));
/* Looking up the reference once again should not retrieve it */
must_fail(git_repository_lookup_ref(&another_looked_up_ref, repo, packed_test_head_name));
must_fail(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
/* Ensure the loose reference doesn't exist any longer on the file system */
must_pass(!gitfo_exists(temp_path));