Reference::~Reference()
{
git_reference_free(ref_);
}
int git_branch_set_upstream(git_reference *branch, const char *upstream_name)
{
git_buf key = GIT_BUF_INIT, value = GIT_BUF_INIT;
git_reference *upstream;
git_repository *repo;
git_remote *remote = NULL;
git_config *config;
const char *name, *shortname;
int local;
const git_refspec *fetchspec;
name = git_reference_name(branch);
if (!git_reference__is_branch(name))
return not_a_local_branch(name);
if (git_repository_config__weakptr(&config, git_reference_owner(branch)) < 0)
return -1;
shortname = name + strlen(GIT_REFS_HEADS_DIR);
if (upstream_name == NULL)
return unset_upstream(config, shortname);
repo = git_reference_owner(branch);
/* First we need to figure out whether it's a branch or remote-tracking */
if (git_branch_lookup(&upstream, repo, upstream_name, GIT_BRANCH_LOCAL) == 0)
local = 1;
else if (git_branch_lookup(&upstream, repo, upstream_name, GIT_BRANCH_REMOTE) == 0)
local = 0;
else {
giterr_set(GITERR_REFERENCE,
"Cannot set upstream for branch '%s'", shortname);
return GIT_ENOTFOUND;
}
/*
* If it's local, the remote is "." and the branch name is
* simply the refname. Otherwise we need to figure out what
* the remote-tracking branch's name on the remote is and use
* that.
*/
if (local)
git_buf_puts(&value, ".");
else
remote_name(&value, repo, git_reference_name(upstream));
if (git_buf_printf(&key, "branch.%s.remote", shortname) < 0)
goto on_error;
if (git_config_set_string(config, git_buf_cstr(&key), git_buf_cstr(&value)) < 0)
goto on_error;
if (local) {
git_buf_clear(&value);
if (git_buf_puts(&value, git_reference_name(upstream)) < 0)
goto on_error;
} else {
/* Get the remoe-tracking branch's refname in its repo */
if (git_remote_load(&remote, repo, git_buf_cstr(&value)) < 0)
goto on_error;
fetchspec = git_remote__matching_dst_refspec(remote, git_reference_name(upstream));
git_buf_clear(&value);
if (!fetchspec || git_refspec_transform_l(&value, fetchspec, git_reference_name(upstream)) < 0)
goto on_error;
git_remote_free(remote);
remote = NULL;
}
git_buf_clear(&key);
if (git_buf_printf(&key, "branch.%s.merge", shortname) < 0)
goto on_error;
if (git_config_set_string(config, git_buf_cstr(&key), git_buf_cstr(&value)) < 0)
goto on_error;
git_reference_free(upstream);
git_buf_free(&key);
git_buf_free(&value);
return 0;
on_error:
git_reference_free(upstream);
git_buf_free(&key);
git_buf_free(&value);
git_remote_free(remote);
return -1;
}
void QGit::listBranchesAndTags()
{
QList<QGitBranch> branches;
git_repository *repo = nullptr;
git_branch_iterator *it = nullptr;
git_reference *ref = nullptr;
git_branch_t type = GIT_BRANCH_ALL;
git_strarray tag_names = {nullptr, 0};
QList<QString> tags;
int res = 0;
QGitError error;
try {
res = git_repository_open(&repo, m_path.absolutePath().toUtf8().constData());
if (res)
{
throw QGitError("git_repository_open", res);
}
res = git_branch_iterator_new(&it, repo, GIT_BRANCH_ALL);
if (res)
{
throw QGitError("git_branch_iterator_new", res);
}
while(git_branch_next(&ref, &type, it) == 0)
{
const char *ref_name = git_reference_name(ref);
QGitBranch branch = QGitBranch(ref_name, type);
branches.append(branch);
ref_name = nullptr;
git_reference_free(ref);
ref = nullptr;
}
res = git_tag_list(&tag_names, repo);
if (res)
{
throw QGitError("git_tag_list", res);
}
for(size_t c = 0; c < tag_names.count; c++)
{
tags.append(QString::fromUtf8(tag_names.strings[c]));
}
} catch(const QGitError &ex) {
error = ex;
}
emit listBranchesAndTagsReply(branches, tags, error);
if (tag_names.strings)
{
git_strarray_free(&tag_names);
tag_names = {nullptr, 0};
}
if(ref)
{
git_reference_free(ref);
ref = nullptr;
}
if (it)
{
git_branch_iterator_free(it);
it = nullptr;
}
if (repo)
{
git_repository_free(repo);
repo = nullptr;
}
}
int lgit_current::discover( git_repository *repo )
{
int error, retval = 0;
const git_oid *oidp;
git_oid oid;
const char *sym;
std::string symbolic_name;
cur_repo_ = repo;
clear();
// Mark one branch as the checked out one
git_reference *ref;
if ( ( error = git_repository_head( &ref, repo ) ) < 0 ) {
state_ = CURRENT_INVALID_MAIN;
MessagesI.AppendMessageT( "Could not determine which branch is currently checked out" );
} else {
switch ( git_reference_type( ref ) ) {
/* GIT_REF_OID */
case GIT_REF_OID:
// Prepare data for .tip_sha
oidp = git_reference_target( ref );
if ( !oidp ) {
state_ = CURRENT_INVALID_OID;
break;
}
state_ = CURRENT_OID;
oid = *oidp;
break;
/* GIT_REF_SYMBOLIC */
case GIT_REF_SYMBOLIC:
sym = git_reference_symbolic_target( ref );
if ( !sym ) {
state_ = CURRENT_INVALID_SYM;
break;
}
state_ = CURRENT_SYM;
symbolic_name = std::string( sym );
// Also establish OID
if ( ( error = git_reference_name_to_id( &oid, repo, symbolic_name.c_str() ) ) < 0 ) {
state_ = CURRENT_INVALID_OID2;
break;
}
break;
/* DEFAULT */
/* GIT_REF_INVALID */
/* GIT_REF_LISTALL */
default:
state_ = CURRENT_INVALID_OTHER;
break;
}
/*
* AFTER SWITCH()
*/
if ( state_ == CURRENT_OID || state_ == CURRENT_SYM ) {
char sha[ GIT_OID_HEXSZ + 1 ];
git_oid_fmt( sha, &oid );
sha[ GIT_OID_HEXSZ ] = '\0';
current_oid_ = std::string( sha );
type_ = CURRENT_TYPE_OID;
}
if ( state_ == CURRENT_OID ) {
// Does the reference have any name?
const char* refname_cstring = git_reference_name( ref );
if( !refname_cstring ) {
refname_cstring = "";
}
QString refname = QString::fromUtf8( refname_cstring ).trimmed();
if( refname.isEmpty() || refname == "HEAD" ) {
git_reflog *reflog;
const git_reflog_entry *reflog_entry;
if ( ( error = git_reflog_read( &reflog, repo, "HEAD" ) ) < 0 ) {
MessagesI.AppendMessageT( QString( "Could not read reflog, current HEAD will be established as SHA-only" ) +
QString( " (no tag name resolution, error code: %1)" ) . arg( error ) );
} else {
int count = git_reflog_entrycount( reflog );
int limit_count = 0;
for ( int i = 0; i < count; i ++ ) {
reflog_entry = git_reflog_entry_byindex( reflog, i );
if( !reflog_entry ) {
MessagesI.AppendMessageT( "Problems when reading reflog" );
continue;
}
oidp = git_reflog_entry_id_new( reflog_entry );
if( 0 == git_oid_cmp( oidp, &oid ) ) {
const char* message_cstring = git_reflog_entry_message( reflog_entry );
if( !message_cstring ) {
MessagesI.AppendMessageT( "Problems when reading reflog (2)" );
continue;
}
QString message = QString( message_cstring );
QRegExp rx("checkout: moving from.*to (.*)$");
if( rx.indexIn( message ) != -1 ) {
// The target of the catched move message must not be current HEAD's OID prefix
if( ! QString::fromStdString( current_oid_ ).startsWith( rx.cap( 1 ) ) ) {
current_tag_ = rx.cap( 1 ).toStdString();
type_ = CURRENT_TYPE_TAG;
}
break;
}
// Search only 5 OID-matching entries
if( ++ limit_count >= 5 ) {
break;
}
}
}
git_reflog_free( reflog );
}
} else {
QStringList parts = refname.split( "/", QString::SkipEmptyParts );
current_branch_ = parts.last().toStdString();
type_ = CURRENT_TYPE_BRANCH;
}
} else if ( state_ == CURRENT_SYM ) {
current_branch_ = symbolic_name;
} else {
MessagesI.AppendMessageT( QString( "Could not determine which branch is currently checked out (error code: %1)" ).arg( state_ ) );
}
git_reference_free( ref );
}
return retval;
}
static int reference__create(
git_reference **ref_out,
git_repository *repo,
const char *name,
const git_oid *oid,
const char *symbolic,
int force,
const git_signature *signature,
const char *log_message,
const git_oid *old_id,
const char *old_target)
{
git_refname_t normalized;
git_refdb *refdb;
git_reference *ref = NULL;
int error = 0;
assert(repo && name);
assert(symbolic || signature);
if (ref_out)
*ref_out = NULL;
error = reference_normalize_for_repo(normalized, repo, name, true);
if (error < 0)
return error;
error = git_repository_refdb__weakptr(&refdb, repo);
if (error < 0)
return error;
if (oid != NULL) {
assert(symbolic == NULL);
if (!git_object__is_valid(repo, oid, GIT_OBJ_ANY)) {
giterr_set(GITERR_REFERENCE,
"target OID for the reference doesn't exist on the repository");
return -1;
}
ref = git_reference__alloc(normalized, oid, NULL);
} else {
git_refname_t normalized_target;
error = reference_normalize_for_repo(normalized_target, repo,
symbolic, git_reference__enable_symbolic_ref_target_validation);
if (error < 0)
return error;
ref = git_reference__alloc_symbolic(normalized, normalized_target);
}
GITERR_CHECK_ALLOC(ref);
if ((error = git_refdb_write(refdb, ref, force, signature, log_message, old_id, old_target)) < 0) {
git_reference_free(ref);
return error;
}
if (ref_out == NULL)
git_reference_free(ref);
else
*ref_out = ref;
return 0;
}
static int retrieve_previously_checked_out_branch_or_revision(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, size_t position)
{
git_reference *ref = NULL;
git_reflog *reflog = NULL;
regex_t preg;
int error = -1;
size_t i, numentries, cur;
const git_reflog_entry *entry;
const char *msg;
regmatch_t regexmatches[2];
git_buf buf = GIT_BUF_INIT;
cur = position;
if (*identifier != '\0' || *base_ref != NULL)
return GIT_EINVALIDSPEC;
if (build_regex(&preg, "checkout: moving from (.*) to .*") < 0)
return -1;
if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
goto cleanup;
if (git_reflog_read(&reflog, repo, GIT_HEAD_FILE) < 0)
goto cleanup;
numentries = git_reflog_entrycount(reflog);
for (i = 0; i < numentries; i++) {
entry = git_reflog_entry_byindex(reflog, i);
msg = git_reflog_entry_message(entry);
if (regexec(&preg, msg, 2, regexmatches, 0))
continue;
cur--;
if (cur > 0)
continue;
git_buf_put(&buf, msg+regexmatches[1].rm_so, regexmatches[1].rm_eo - regexmatches[1].rm_so);
if ((error = git_reference_dwim(base_ref, repo, git_buf_cstr(&buf))) == 0)
goto cleanup;
if (error < 0 && error != GIT_ENOTFOUND)
goto cleanup;
error = maybe_abbrev(out, repo, git_buf_cstr(&buf));
goto cleanup;
}
error = GIT_ENOTFOUND;
cleanup:
git_reference_free(ref);
git_buf_free(&buf);
regfree(&preg);
git_reflog_free(reflog);
return error;
}
void test_rebase_iterator__iterates(void)
{
git_rebase *rebase;
git_reference *branch_ref, *upstream_ref;
git_annotated_commit *branch_head, *upstream_head;
git_rebase_operation *rebase_operation;
git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
git_oid commit_id;
int error;
checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef"));
cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/master"));
cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref));
cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref));
cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, signature, NULL));
test_operations(rebase, 0);
git_rebase_free(rebase);
cl_git_pass(git_rebase_open(&rebase, repo));
cl_git_pass(git_rebase_next(&rebase_operation, rebase, &checkout_opts));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature,
NULL, NULL));
test_operations(rebase, 0);
cl_git_pass(git_rebase_next(&rebase_operation, rebase, &checkout_opts));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature,
NULL, NULL));
test_operations(rebase, 1);
cl_git_pass(git_rebase_next(&rebase_operation, rebase, &checkout_opts));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature,
NULL, NULL));
test_operations(rebase, 2);
git_rebase_free(rebase);
cl_git_pass(git_rebase_open(&rebase, repo));
cl_git_pass(git_rebase_next(&rebase_operation, rebase, &checkout_opts));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature,
NULL, NULL));
test_operations(rebase, 3);
cl_git_pass(git_rebase_next(&rebase_operation, rebase, &checkout_opts));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature,
NULL, NULL));
test_operations(rebase, 4);
cl_git_fail(error = git_rebase_next(&rebase_operation, rebase, &checkout_opts));
cl_assert_equal_i(GIT_ITEROVER, error);
test_operations(rebase, 4);
git_annotated_commit_free(branch_head);
git_annotated_commit_free(upstream_head);
git_reference_free(branch_ref);
git_reference_free(upstream_ref);
git_rebase_free(rebase);
}
/* git revert --no-commit 72333f47d4e83616630ff3b0ffe4c0faebcc3c45 */
void test_revert_workdir__conflicts(void)
{
git_reference *head_ref;
git_commit *head, *commit;
git_oid revert_oid;
git_buf conflicting_buf = GIT_BUF_INIT, mergemsg_buf = GIT_BUF_INIT;
struct merge_index_entry merge_index_entries[] = {
{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 1, "file1.txt" },
{ 0100644, "4b8fcff56437e60f58e9a6bc630dd242ebf6ea2c", 2, "file1.txt" },
{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 3, "file1.txt" },
{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
};
git_oid_fromstr(&revert_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
cl_git_pass(git_repository_head(&head_ref, repo));
cl_git_pass(git_reference_peel((git_object **)&head, head_ref, GIT_OBJ_COMMIT));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
cl_git_pass(git_revert(repo, commit, NULL));
cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
cl_git_pass(git_futils_readbuffer(&conflicting_buf,
TEST_REPO_PATH "/file1.txt"));
cl_assert(strcmp(conflicting_buf.ptr, "!File one!\n" \
"!File one!\n" \
"File one!\n" \
"File one\n" \
"File one\n" \
"File one\n" \
"File one\n" \
"File one\n" \
"File one\n" \
"File one\n" \
"<<<<<<< HEAD\n" \
"File one!\n" \
"!File one!\n" \
"!File one!\n" \
"!File one!\n" \
"=======\n" \
"File one\n" \
"File one\n" \
"File one\n" \
"File one\n" \
">>>>>>> parent of 72333f4... automergeable changes\n") == 0);
cl_assert(git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
cl_git_pass(git_futils_readbuffer(&mergemsg_buf,
TEST_REPO_PATH "/.git/MERGE_MSG"));
cl_assert(strcmp(mergemsg_buf.ptr,
"Revert \"automergeable changes\"\n" \
"\n" \
"This reverts commit 72333f47d4e83616630ff3b0ffe4c0faebcc3c45.\n"
"\n" \
"Conflicts:\n" \
"\tfile1.txt\n") == 0);
git_commit_free(commit);
git_commit_free(head);
git_reference_free(head_ref);
git_buf_free(&mergemsg_buf);
git_buf_free(&conflicting_buf);
}
void test_threads_refdb__edit_while_iterate(void)
{
int r, t;
struct th_data th_data[THREADS];
git_oid head;
git_reference *ref;
char name[128];
git_refdb *refdb;
#ifdef GIT_THREADS
git_thread th[THREADS];
#endif
g_repo = cl_git_sandbox_init("testrepo2");
cl_git_pass(git_reference_name_to_id(&head, g_repo, "HEAD"));
/* make a bunch of references */
for (r = 0; r < 50; ++r) {
p_snprintf(name, sizeof(name), "refs/heads/starter-%03d", r);
cl_git_pass(git_reference_create(&ref, g_repo, name, &head, 0, NULL));
git_reference_free(ref);
}
cl_git_pass(git_repository_refdb(&refdb, g_repo));
cl_git_pass(git_refdb_compress(refdb));
git_refdb_free(refdb);
g_expected = -1;
g_repo = cl_git_sandbox_reopen(); /* reopen to flush caches */
for (t = 0; t < THREADS; ++t) {
void *(*fn)(void *arg);
switch (t & 0x3) {
case 0: fn = create_refs; break;
case 1: fn = delete_refs; break;
default: fn = iterate_refs; break;
}
th_data[t].id = t;
th_data[t].path = git_repository_path(g_repo);
#ifdef GIT_THREADS
cl_git_pass(git_thread_create(&th[t], fn, &th_data[t]));
#else
fn(&th_data[t]);
#endif
}
#ifdef GIT_THREADS
for (t = 0; t < THREADS; ++t) {
cl_git_pass(git_thread_join(&th[t], NULL));
cl_git_thread_check(&th_data[t]);
}
memset(th, 0, sizeof(th));
for (t = 0; t < THREADS; ++t) {
th_data[t].id = t;
cl_git_pass(git_thread_create(&th[t], iterate_refs, &th_data[t]));
}
for (t = 0; t < THREADS; ++t) {
cl_git_pass(git_thread_join(&th[t], NULL));
cl_git_thread_check(&th_data[t]);
}
#endif
}
void test_rebase_merge__next_with_conflicts(void)
{
git_rebase *rebase;
git_reference *branch_ref, *upstream_ref;
git_annotated_commit *branch_head, *upstream_head;
git_rebase_operation *rebase_operation;
git_status_list *status_list;
const git_status_entry *status_entry;
git_oid pick_id, commit_id;
const char *expected_merge =
"ASPARAGUS SOUP.\n"
"\n"
"<<<<<<< master\n"
"TAKE FOUR LARGE BUNCHES of asparagus, scrape it nicely, cut off one inch\n"
"OF THE TOPS, and lay them in water, chop the stalks and put them on the\n"
"FIRE WITH A PIECE OF BACON, a large onion cut up, and pepper and salt;\n"
"ADD TWO QUARTS OF WATER, boil them till the stalks are quite soft, then\n"
"PULP THEM THROUGH A SIEVE, and strain the water to it, which must be put\n"
"=======\n"
"Take four large bunches of asparagus, scrape it nicely, CUT OFF ONE INCH\n"
"of the tops, and lay them in water, chop the stalks and PUT THEM ON THE\n"
"fire with a piece of bacon, a large onion cut up, and pepper and salt;\n"
"add two quarts of water, boil them till the stalks are quite soft, then\n"
"pulp them through a sieve, and strain the water to it, which must be put\n"
">>>>>>> Conflicting modification 1 to asparagus\n"
"back in the pot; put into it a chicken cut up, with the tops of\n"
"asparagus which had been laid by, boil it until these last articles are\n"
"sufficiently done, thicken with flour, butter and milk, and serve it up.\n";
cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/asparagus"));
cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/master"));
cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref));
cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref));
cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, NULL));
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
git_oid_fromstr(&pick_id, "33f915f9e4dbd9f4b24430e48731a59b45b15500");
cl_assert_equal_i(GIT_REBASE_OPERATION_PICK, rebase_operation->type);
cl_assert_equal_oid(&pick_id, &rebase_operation->id);
cl_assert_equal_file("33f915f9e4dbd9f4b24430e48731a59b45b15500\n", 41, "rebase/.git/rebase-merge/current");
cl_assert_equal_file("1\n", 2, "rebase/.git/rebase-merge/msgnum");
cl_git_pass(git_status_list_new(&status_list, repo, NULL));
cl_assert_equal_i(1, git_status_list_entrycount(status_list));
cl_assert(status_entry = git_status_byindex(status_list, 0));
cl_assert_equal_s("asparagus.txt", status_entry->head_to_index->new_file.path);
cl_assert_equal_file(expected_merge, strlen(expected_merge), "rebase/asparagus.txt");
cl_git_fail_with(GIT_EUNMERGED, git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL));
git_status_list_free(status_list);
git_annotated_commit_free(branch_head);
git_annotated_commit_free(upstream_head);
git_reference_free(branch_ref);
git_reference_free(upstream_ref);
git_rebase_free(rebase);
}
// create a root commit
void test_commit_write__root(void)
{
git_oid tree_id, commit_id;
const git_oid *branch_oid;
git_signature *author, *committer;
const char *branch_name = "refs/heads/root-commit-branch";
git_tree *tree;
git_reflog *log;
const git_reflog_entry *entry;
git_oid_fromstr(&tree_id, tree_oid);
cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
/* create signatures */
cl_git_pass(git_signature_new(&committer, committer_name, committer_email, 123456789, 60));
cl_git_pass(git_signature_new(&author, committer_name, committer_email, 987654321, 90));
/* First we need to update HEAD so it points to our non-existant branch */
cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
cl_assert(git_reference_type(head) == GIT_REF_SYMBOLIC);
head_old = git__strdup(git_reference_symbolic_target(head));
cl_assert(head_old != NULL);
git_reference_free(head);
cl_git_pass(git_reference_symbolic_create(&head, g_repo, "HEAD", branch_name, 1, NULL, NULL));
cl_git_pass(git_commit_create_v(
&commit_id, /* out id */
g_repo,
"HEAD",
author,
committer,
NULL,
root_commit_message,
tree,
0));
git_object_free((git_object *)tree);
git_signature_free(author);
/*
* The fact that creating a commit works has already been
* tested. Here we just make sure it's our commit and that it was
* written as a root commit.
*/
cl_git_pass(git_commit_lookup(&commit, g_repo, &commit_id));
cl_assert(git_commit_parentcount(commit) == 0);
cl_git_pass(git_reference_lookup(&branch, g_repo, branch_name));
branch_oid = git_reference_target(branch);
cl_git_pass(git_oid_cmp(branch_oid, &commit_id));
cl_assert_equal_s(root_commit_message, git_commit_message(commit));
cl_git_pass(git_reflog_read(&log, g_repo, branch_name));
cl_assert_equal_i(1, git_reflog_entrycount(log));
entry = git_reflog_entry_byindex(log, 0);
cl_assert_equal_s(committer->email, git_reflog_entry_committer(entry)->email);
cl_assert_equal_s(committer->name, git_reflog_entry_committer(entry)->name);
cl_assert_equal_s(root_reflog_message, git_reflog_entry_message(entry));
git_signature_free(committer);
git_reflog_free(log);
}
int luagi_reference_gen_free( lua_State *L, const char *tablename )
{
git_reference **ref = luaL_checkudata( L, 1, tablename );
git_reference_free( *ref );
return 0;
}
void rb_git_ref__free(git_reference *ref)
{
git_reference_free(ref);
}
static int reference__create(
git_reference **ref_out,
git_repository *repo,
const char *name,
const git_oid *oid,
const char *symbolic,
int force,
const git_signature *signature,
const char *log_message,
const git_oid *old_id,
const char *old_target)
{
git_refname_t normalized;
git_refdb *refdb;
git_reference *ref = NULL;
int error = 0;
assert(repo && name);
assert(symbolic || signature);
if (ref_out)
*ref_out = NULL;
error = reference_normalize_for_repo(normalized, repo, name);
if (error < 0)
return error;
error = git_repository_refdb__weakptr(&refdb, repo);
if (error < 0)
return error;
if (oid != NULL) {
git_odb *odb;
assert(symbolic == NULL);
/* Sanity check the reference being created - target must exist. */
if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
return error;
if (!git_odb_exists(odb, oid)) {
giterr_set(GITERR_REFERENCE,
"Target OID for the reference doesn't exist on the repository");
return -1;
}
ref = git_reference__alloc(normalized, oid, NULL);
} else {
git_refname_t normalized_target;
if ((error = reference_normalize_for_repo(normalized_target, repo, symbolic)) < 0)
return error;
ref = git_reference__alloc_symbolic(normalized, normalized_target);
}
GITERR_CHECK_ALLOC(ref);
if ((error = git_refdb_write(refdb, ref, force, signature, log_message, old_id, old_target)) < 0) {
git_reference_free(ref);
return error;
}
if (ref_out == NULL)
git_reference_free(ref);
else
*ref_out = ref;
return 0;
}
void test_submodule_update__update_already_checked_out_submodule(void)
{
git_submodule *sm = NULL;
git_checkout_options checkout_options = GIT_CHECKOUT_OPTIONS_INIT;
git_submodule_update_options update_options = GIT_SUBMODULE_UPDATE_OPTIONS_INIT;
unsigned int submodule_status = 0;
git_reference *branch_reference = NULL;
git_object *branch_commit = NULL;
struct update_submodule_cb_payload update_payload = { 0 };
g_repo = setup_fixture_submodule_simple();
update_options.checkout_opts.progress_cb = checkout_progress_cb;
update_options.checkout_opts.progress_payload = &update_payload;
/* Initialize and update the sub repository */
cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo"));
cl_git_pass(git_submodule_status(&submodule_status, sm));
cl_assert_equal_i(submodule_status, GIT_SUBMODULE_STATUS_IN_HEAD |
GIT_SUBMODULE_STATUS_IN_INDEX |
GIT_SUBMODULE_STATUS_IN_CONFIG |
GIT_SUBMODULE_STATUS_WD_UNINITIALIZED);
cl_git_pass(git_submodule_update(sm, 1, &update_options));
/* verify expected state */
cl_assert(git_oid_streq(git_submodule_head_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0);
cl_assert(git_oid_streq(git_submodule_wd_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0);
cl_assert(git_oid_streq(git_submodule_index_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0);
/* checkout the alternate_1 branch */
checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE;
cl_git_pass(git_reference_lookup(&branch_reference, g_repo, "refs/heads/alternate_1"));
cl_git_pass(git_reference_peel(&branch_commit, branch_reference, GIT_OBJ_COMMIT));
cl_git_pass(git_checkout_tree(g_repo, branch_commit, &checkout_options));
cl_git_pass(git_repository_set_head(g_repo, git_reference_name(branch_reference)));
/*
* Verify state after checkout of parent repository. The submodule ID in the
* HEAD commit and index should be updated, but not the workdir.
*/
cl_git_pass(git_submodule_status(&submodule_status, sm));
cl_assert_equal_i(submodule_status, GIT_SUBMODULE_STATUS_IN_HEAD |
GIT_SUBMODULE_STATUS_IN_INDEX |
GIT_SUBMODULE_STATUS_IN_CONFIG |
GIT_SUBMODULE_STATUS_IN_WD |
GIT_SUBMODULE_STATUS_WD_MODIFIED);
cl_assert(git_oid_streq(git_submodule_head_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
cl_assert(git_oid_streq(git_submodule_wd_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0);
cl_assert(git_oid_streq(git_submodule_index_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
/*
* Update the submodule and verify the state.
* Now, the HEAD, index, and Workdir commits should all be updated to
* the new commit.
*/
cl_git_pass(git_submodule_update(sm, 0, &update_options));
cl_assert(git_oid_streq(git_submodule_head_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
cl_assert(git_oid_streq(git_submodule_wd_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
cl_assert(git_oid_streq(git_submodule_index_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
/* verify that the expected callbacks have been called. */
cl_assert_equal_i(1, update_payload.checkout_progress_called);
git_submodule_free(sm);
git_object_free(branch_commit);
git_reference_free(branch_reference);
}
int git_commit_amend(
git_oid *id,
const git_commit *commit_to_amend,
const char *update_ref,
const git_signature *author,
const git_signature *committer,
const char *message_encoding,
const char *message,
const git_tree *tree)
{
git_repository *repo;
git_oid tree_id;
git_reference *ref;
int error;
assert(id && commit_to_amend);
repo = git_commit_owner(commit_to_amend);
if (!author)
author = git_commit_author(commit_to_amend);
if (!committer)
committer = git_commit_committer(commit_to_amend);
if (!message_encoding)
message_encoding = git_commit_message_encoding(commit_to_amend);
if (!message)
message = git_commit_message(commit_to_amend);
if (!tree) {
git_tree *old_tree;
GITERR_CHECK_ERROR( git_commit_tree(&old_tree, commit_to_amend) );
git_oid_cpy(&tree_id, git_tree_id(old_tree));
git_tree_free(old_tree);
} else {
assert(git_tree_owner(tree) == repo);
git_oid_cpy(&tree_id, git_tree_id(tree));
}
if (update_ref) {
if ((error = git_reference_lookup_resolved(&ref, repo, update_ref, 5)) < 0)
return error;
if (git_oid_cmp(git_commit_id(commit_to_amend), git_reference_target(ref))) {
git_reference_free(ref);
giterr_set(GITERR_REFERENCE, "commit to amend is not the tip of the given branch");
return -1;
}
}
error = git_commit_create_from_callback(
id, repo, NULL, author, committer, message_encoding, message,
&tree_id, commit_parent_for_amend, (void *)commit_to_amend);
if (!error && update_ref) {
error = git_reference__update_for_commit(
repo, ref, NULL, id, committer, "commit");
git_reference_free(ref);
}
return error;
}
void test_submodule_update__can_force_update(void)
{
git_submodule *sm = NULL;
git_checkout_options checkout_options = GIT_CHECKOUT_OPTIONS_INIT;
git_submodule_update_options update_options = GIT_SUBMODULE_UPDATE_OPTIONS_INIT;
unsigned int submodule_status = 0;
git_reference *branch_reference = NULL;
git_object *branch_commit = NULL;
g_repo = setup_fixture_submodule_simple();
/* Initialize and update the sub repository */
cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo"));
cl_git_pass(git_submodule_status(&submodule_status, sm));
cl_assert_equal_i(submodule_status, GIT_SUBMODULE_STATUS_IN_HEAD |
GIT_SUBMODULE_STATUS_IN_INDEX |
GIT_SUBMODULE_STATUS_IN_CONFIG |
GIT_SUBMODULE_STATUS_WD_UNINITIALIZED);
cl_git_pass(git_submodule_update(sm, 1, &update_options));
/* verify expected state */
cl_assert(git_oid_streq(git_submodule_head_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0);
cl_assert(git_oid_streq(git_submodule_wd_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0);
cl_assert(git_oid_streq(git_submodule_index_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0);
/* checkout the alternate_1 branch */
checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE;
cl_git_pass(git_reference_lookup(&branch_reference, g_repo, "refs/heads/alternate_1"));
cl_git_pass(git_reference_peel(&branch_commit, branch_reference, GIT_OBJ_COMMIT));
cl_git_pass(git_checkout_tree(g_repo, branch_commit, &checkout_options));
cl_git_pass(git_repository_set_head(g_repo, git_reference_name(branch_reference)));
/*
* Verify state after checkout of parent repository. The submodule ID in the
* HEAD commit and index should be updated, but not the workdir.
*/
cl_git_pass(git_submodule_status(&submodule_status, sm));
cl_assert_equal_i(submodule_status, GIT_SUBMODULE_STATUS_IN_HEAD |
GIT_SUBMODULE_STATUS_IN_INDEX |
GIT_SUBMODULE_STATUS_IN_CONFIG |
GIT_SUBMODULE_STATUS_IN_WD |
GIT_SUBMODULE_STATUS_WD_MODIFIED);
cl_assert(git_oid_streq(git_submodule_head_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
cl_assert(git_oid_streq(git_submodule_wd_id(sm), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644") == 0);
cl_assert(git_oid_streq(git_submodule_index_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
/*
* Create a conflicting edit in the subrepository to verify that
* the submodule update action is blocked.
*/
cl_git_write2file("submodule_simple/testrepo/branch_file.txt", "a conflicting edit", 0,
O_WRONLY | O_CREAT | O_TRUNC, 0777);
/* forcefully checkout and verify the submodule state was updated. */
update_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE;
cl_git_pass(git_submodule_update(sm, 0, &update_options));
cl_assert(git_oid_streq(git_submodule_head_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
cl_assert(git_oid_streq(git_submodule_wd_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
cl_assert(git_oid_streq(git_submodule_index_id(sm), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750") == 0);
git_submodule_free(sm);
git_object_free(branch_commit);
git_reference_free(branch_reference);
}
int git_commit_create_from_callback(
git_oid *id,
git_repository *repo,
const char *update_ref,
const git_signature *author,
const git_signature *committer,
const char *message_encoding,
const char *message,
const git_oid *tree,
git_commit_parent_callback parent_cb,
void *parent_payload)
{
git_reference *ref = NULL;
int error = 0, matched_parent = 0;
const git_oid *current_id = NULL;
git_buf commit = GIT_BUF_INIT;
size_t i = 0;
git_odb *odb;
const git_oid *parent;
assert(id && repo && tree && parent_cb);
if (update_ref) {
error = git_reference_lookup_resolved(&ref, repo, update_ref, 10);
if (error < 0 && error != GIT_ENOTFOUND)
return error;
}
giterr_clear();
if (ref)
current_id = git_reference_target(ref);
git_oid__writebuf(&commit, "tree ", tree);
while ((parent = parent_cb(i, parent_payload)) != NULL) {
git_oid__writebuf(&commit, "parent ", parent);
if (i == 0 && current_id && git_oid_equal(current_id, parent))
matched_parent = 1;
i++;
}
if (ref && !matched_parent) {
git_reference_free(ref);
git_buf_free(&commit);
giterr_set(GITERR_OBJECT, "failed to create commit: current tip is not the first parent");
return GIT_EMODIFIED;
}
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');
if (git_buf_puts(&commit, message) < 0)
goto on_error;
if (git_repository_odb__weakptr(&odb, repo) < 0)
goto on_error;
if (git_odb_write(id, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT) < 0)
goto on_error;
git_buf_free(&commit);
if (update_ref != NULL) {
error = git_reference__update_for_commit(
repo, ref, update_ref, id, committer, "commit");
git_reference_free(ref);
return error;
}
return 0;
on_error:
git_buf_free(&commit);
giterr_set(GITERR_OBJECT, "Failed to create commit.");
return -1;
}
int revparse__ext(
git_object **object_out,
git_reference **reference_out,
size_t *identifier_len_out,
git_repository *repo,
const char *spec)
{
size_t pos = 0, identifier_len = 0;
int error = -1, n;
git_buf buf = GIT_BUF_INIT;
git_reference *reference = NULL;
git_object *base_rev = NULL;
bool should_return_reference = true;
assert(object_out && reference_out && repo && spec);
*object_out = NULL;
*reference_out = NULL;
while (spec[pos]) {
switch (spec[pos]) {
case '^':
should_return_reference = false;
if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, false)) < 0)
goto cleanup;
if (spec[pos+1] == '{') {
git_object *temp_object = NULL;
if ((error = extract_curly_braces_content(&buf, spec, &pos)) < 0)
goto cleanup;
if ((error = handle_caret_curly_syntax(&temp_object, base_rev, git_buf_cstr(&buf))) < 0)
goto cleanup;
git_object_free(base_rev);
base_rev = temp_object;
} else {
git_object *temp_object = NULL;
if ((error = extract_how_many(&n, spec, &pos)) < 0)
goto cleanup;
if ((error = handle_caret_parent_syntax(&temp_object, base_rev, n)) < 0)
goto cleanup;
git_object_free(base_rev);
base_rev = temp_object;
}
break;
case '~':
{
git_object *temp_object = NULL;
should_return_reference = false;
if ((error = extract_how_many(&n, spec, &pos)) < 0)
goto cleanup;
if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, false)) < 0)
goto cleanup;
if ((error = handle_linear_syntax(&temp_object, base_rev, n)) < 0)
goto cleanup;
git_object_free(base_rev);
base_rev = temp_object;
break;
}
case ':':
{
git_object *temp_object = NULL;
should_return_reference = false;
if ((error = extract_path(&buf, spec, &pos)) < 0)
goto cleanup;
if (any_left_hand_identifier(base_rev, reference, identifier_len)) {
if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, true)) < 0)
goto cleanup;
if ((error = handle_colon_syntax(&temp_object, base_rev, git_buf_cstr(&buf))) < 0)
goto cleanup;
} else {
if (*git_buf_cstr(&buf) == '/') {
if ((error = handle_grep_syntax(&temp_object, repo, NULL, git_buf_cstr(&buf) + 1)) < 0)
goto cleanup;
} else {
/*
* TODO: support merge-stage path lookup (":2:Makefile")
* and plain index blob lookup (:i-am/a/blob)
*/
giterr_set(GITERR_INVALID, "Unimplemented");
error = GIT_ERROR;
goto cleanup;
}
}
git_object_free(base_rev);
base_rev = temp_object;
break;
}
case '@':
{
if (spec[pos+1] == '{') {
git_object *temp_object = NULL;
if ((error = extract_curly_braces_content(&buf, spec, &pos)) < 0)
goto cleanup;
if ((error = ensure_base_rev_is_not_known_yet(base_rev)) < 0)
goto cleanup;
if ((error = handle_at_syntax(&temp_object, &reference, spec, identifier_len, repo, git_buf_cstr(&buf))) < 0)
goto cleanup;
if (temp_object != NULL)
base_rev = temp_object;
break;
} else {
/* Fall through */
}
}
default:
if ((error = ensure_left_hand_identifier_is_not_known_yet(base_rev, reference)) < 0)
goto cleanup;
pos++;
identifier_len++;
}
}
if ((error = ensure_base_rev_loaded(&base_rev, &reference, spec, identifier_len, repo, false)) < 0)
goto cleanup;
if (!should_return_reference) {
git_reference_free(reference);
reference = NULL;
}
*object_out = base_rev;
*reference_out = reference;
*identifier_len_out = identifier_len;
error = 0;
cleanup:
if (error) {
if (error == GIT_EINVALIDSPEC)
giterr_set(GITERR_INVALID,
"Failed to parse revision specifier - Invalid pattern '%s'", spec);
git_object_free(base_rev);
git_reference_free(reference);
}
git_buf_free(&buf);
return error;
}
void test_rebase_inmemory__can_resolve_conflicts(void)
{
git_rebase *rebase;
git_reference *branch_ref, *upstream_ref;
git_annotated_commit *branch_head, *upstream_head;
git_rebase_operation *rebase_operation;
git_status_list *status_list;
git_oid pick_id, commit_id, expected_commit_id;
git_signature *signature;
git_index *repo_index;
git_index_entry resolution = {{0}};
git_rebase_options opts = GIT_REBASE_OPTIONS_INIT;
cl_git_pass(git_signature_new(&signature,
"Rebaser", "*****@*****.**", 1405694510, 0));
opts.inmemory = true;
cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/asparagus"));
cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/master"));
cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref));
cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref));
cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, &opts));
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
git_oid_fromstr(&pick_id, "33f915f9e4dbd9f4b24430e48731a59b45b15500");
cl_assert_equal_i(GIT_REBASE_OPERATION_PICK, rebase_operation->type);
cl_assert_equal_oid(&pick_id, &rebase_operation->id);
/* ensure that we did not do anything stupid to the workdir or repo index */
cl_git_pass(git_repository_index(&repo_index, repo));
cl_assert(!git_index_has_conflicts(repo_index));
cl_git_pass(git_status_list_new(&status_list, repo, NULL));
cl_assert_equal_i(0, git_status_list_entrycount(status_list));
/* but that the index returned from rebase does have conflicts */
cl_assert(git_index_has_conflicts(rebase_operation->index));
cl_git_fail_with(GIT_EUNMERGED, git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL));
/* ensure that we can work with the in-memory index to resolve the conflict */
resolution.path = "asparagus.txt";
resolution.mode = GIT_FILEMODE_BLOB;
git_oid_fromstr(&resolution.id, "414dfc71ead79c07acd4ea47fecf91f289afc4b9");
cl_git_pass(git_index_conflict_remove(rebase_operation->index, "asparagus.txt"));
cl_git_pass(git_index_add(rebase_operation->index, &resolution));
/* and finally create a commit for the resolved rebase operation */
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL));
cl_git_pass(git_oid_fromstr(&expected_commit_id, "db7af47222181e548810da2ab5fec0e9357c5637"));
cl_assert_equal_oid(&commit_id, &expected_commit_id);
git_signature_free(signature);
git_status_list_free(status_list);
git_annotated_commit_free(branch_head);
git_annotated_commit_free(upstream_head);
git_reference_free(branch_ref);
git_reference_free(upstream_ref);
git_index_free(repo_index);
git_rebase_free(rebase);
}
static int rebase_commit_merge(
git_oid *commit_id,
git_rebase *rebase,
const git_signature *author,
const git_signature *committer,
const char *message_encoding,
const char *message)
{
git_index *index = NULL;
git_reference *head = NULL;
git_commit *current_commit = NULL, *head_commit = NULL, *commit = NULL;
git_rebase_operation *operation;
git_tree *head_tree = NULL, *tree = NULL;
git_diff *diff = NULL;
git_oid tree_id;
git_buf reflog_msg = GIT_BUF_INIT;
char old_idstr[GIT_OID_HEXSZ], new_idstr[GIT_OID_HEXSZ];
int error;
operation = git_array_get(rebase->operations, rebase->current);
assert(operation);
if ((error = git_repository_index(&index, rebase->repo)) < 0)
goto done;
if (git_index_has_conflicts(index)) {
giterr_set(GITERR_REBASE, "Conflicts have not been resolved");
error = GIT_EMERGECONFLICT;
goto done;
}
if ((error = git_commit_lookup(¤t_commit, rebase->repo, &operation->id)) < 0 ||
(error = git_repository_head(&head, rebase->repo)) < 0 ||
(error = git_reference_peel((git_object **)&head_commit, head, GIT_OBJ_COMMIT)) < 0 ||
(error = git_commit_tree(&head_tree, head_commit)) < 0 ||
(error = git_diff_tree_to_index(&diff, rebase->repo, head_tree, index, NULL)) < 0)
goto done;
if (git_diff_num_deltas(diff) == 0) {
giterr_set(GITERR_REBASE, "This patch has already been applied");
error = GIT_EAPPLIED;
goto done;
}
if ((error = git_index_write_tree(&tree_id, index)) < 0 ||
(error = git_tree_lookup(&tree, rebase->repo, &tree_id)) < 0)
goto done;
if (!author)
author = git_commit_author(current_commit);
if (!message) {
message_encoding = git_commit_message_encoding(current_commit);
message = git_commit_message(current_commit);
}
if ((error = git_commit_create(commit_id, rebase->repo, NULL, author,
committer, message_encoding, message, tree, 1,
(const git_commit **)&head_commit)) < 0 ||
(error = git_commit_lookup(&commit, rebase->repo, commit_id)) < 0 ||
(error = git_reference__update_for_commit(
rebase->repo, NULL, "HEAD", commit_id, committer, "rebase")) < 0)
goto done;
git_oid_fmt(old_idstr, git_commit_id(current_commit));
git_oid_fmt(new_idstr, commit_id);
error = rebase_setupfile(rebase, REWRITTEN_FILE, O_CREAT|O_WRONLY|O_APPEND,
"%.*s %.*s\n", GIT_OID_HEXSZ, old_idstr, GIT_OID_HEXSZ, new_idstr);
done:
git_buf_free(&reflog_msg);
git_commit_free(commit);
git_diff_free(diff);
git_tree_free(tree);
git_tree_free(head_tree);
git_commit_free(head_commit);
git_commit_free(current_commit);
git_reference_free(head);
git_index_free(index);
return error;
}
QByteArray PmrWorkspace::headFileContents(const QString &pFileName)
{
// Retrieve the contents of the given file name at the HEAD revision
// Note: the below code is based on Repository::GetHeadBlob() from git-utils
// (see https://github.com/atom/git-utils)...
git_reference *head;
if (git_repository_head(&head, mGitRepository) != GIT_OK) {
return {};
}
const git_oid *sha = git_reference_target(head);
git_commit *commit;
int commitStatus = git_commit_lookup(&commit, mGitRepository, sha);
git_reference_free(head);
if (commitStatus != GIT_OK) {
return {};
}
git_tree *tree;
int treeStatus = git_commit_tree(&tree, commit);
git_commit_free(commit);
if (treeStatus != GIT_OK) {
return {};
}
git_tree_entry *treeEntry;
if (git_tree_entry_bypath(&treeEntry, tree, pFileName.toUtf8().constData()) != GIT_OK) {
git_tree_free(tree);
return {};
}
git_blob *blob = nullptr;
const git_oid *blobSha = git_tree_entry_id(treeEntry);
if ( (blobSha != nullptr)
&& (git_blob_lookup(&blob, mGitRepository, blobSha) != GIT_OK)) {
blob = nullptr;
}
git_tree_entry_free(treeEntry);
git_tree_free(tree);
if (blob == nullptr) {
return {};
}
QByteArray res(static_cast<const char *>(git_blob_rawcontent(blob)),
int(git_blob_rawsize(blob)));
git_blob_free(blob);
return res;
}
void test_threads_refdb__edit_while_iterate(void)
{
int r, t;
int id[THREADS];
git_oid head;
git_reference *ref;
char name[128];
git_refdb *refdb;
#ifdef GIT_THREADS
git_thread th[THREADS];
#endif
g_repo = cl_git_sandbox_init("testrepo2");
cl_git_pass(git_reference_name_to_id(&head, g_repo, "HEAD"));
/* make a bunch of references */
for (r = 0; r < 50; ++r) {
p_snprintf(name, sizeof(name), "refs/heads/starter-%03d", r);
cl_git_pass(git_reference_create(&ref, g_repo, name, &head, 0, NULL));
git_reference_free(ref);
}
cl_git_pass(git_repository_refdb(&refdb, g_repo));
cl_git_pass(git_refdb_compress(refdb));
git_refdb_free(refdb);
g_expected = -1;
g_repo = cl_git_sandbox_reopen(); /* reopen to flush caches */
for (t = 0; t < THREADS; ++t) {
void *(*fn)(void *arg);
switch (t & 0x3) {
case 0: fn = create_refs; break;
case 1: fn = delete_refs; break;
default: fn = iterate_refs; break;
}
id[t] = t;
/* It appears with all reflog writing changes, etc., that this
* test has started to fail quite frequently, so let's disable it
* for now by just running on a single thread...
*/
/* #ifdef GIT_THREADS */
/* cl_git_pass(git_thread_create(&th[t], fn, &id[t])); */
/* #else */
fn(&id[t]);
/* #endif */
}
#ifdef GIT_THREADS
/* for (t = 0; t < THREADS; ++t) { */
/* cl_git_pass(git_thread_join(th[t], NULL)); */
/* } */
memset(th, 0, sizeof(th));
for (t = 0; t < THREADS; ++t) {
id[t] = t;
cl_git_pass(git_thread_create(&th[t], iterate_refs, &id[t]));
}
for (t = 0; t < THREADS; ++t) {
cl_git_pass(git_thread_join(&th[t], NULL));
}
#endif
}
void PmrWorkspace::stageFile(const QString &pPath, bool pStage)
{
// Un/stage the file, which path is given, and let people know of the
// outcome
if (isOpen()) {
QByteArray relativePathByteArray = QDir(mPath).relativeFilePath(pPath).toUtf8();
const char *relativePath = relativePathByteArray.constData();
bool success = false;
git_index *index;
if (git_repository_index(&index, mGitRepository) == GIT_OK) {
if (pStage) {
uint statusFlags = 0;
git_status_file(&statusFlags, mGitRepository, relativePath);
if ((statusFlags & GIT_STATUS_WT_DELETED) != 0) {
success = git_index_remove_bypath(index, relativePath) == GIT_OK;
} else {
success = git_index_add_bypath(index, relativePath) == GIT_OK;
}
} else if (git_repository_head_unborn(mGitRepository) == 1) {
success = git_index_remove_bypath(index, relativePath) == GIT_OK;
} else {
// We need to add a "reset stage" to the index, which means
// getting the tree for HEAD and tree_entry for the file
git_reference *head;
if (git_repository_head(&head, mGitRepository) == GIT_OK) {
git_tree *headTree;
if (git_reference_peel(reinterpret_cast<git_object **>(&headTree),
head, GIT_OBJECT_TREE) == GIT_OK) {
git_tree_entry *headEntry;
if (git_tree_entry_bypath(&headEntry, headTree,
relativePath) == GIT_OK) {
git_index_entry indexEntry;
memset(&indexEntry, '\0', sizeof(git_index_entry));
indexEntry.id = *git_tree_entry_id(headEntry);
indexEntry.mode = uint32_t(git_tree_entry_filemode(headEntry));
indexEntry.path = relativePath;
git_index_add(index, &indexEntry);
git_tree_entry_free(headEntry);
success = true;
} else {
success = git_index_remove_bypath(index, relativePath) == GIT_OK;
}
git_tree_free(headTree);
}
git_reference_free(head);
}
}
if (success) {
git_index_write(index);
}
git_index_free(index);
}
if (!success) {
emitGitError(tr("An error occurred while trying to stage %1.").arg(pPath));
}
}
}
int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *buffer, int allow_ref_overwrite)
{
git_tag tag;
int error;
git_odb *odb;
git_odb_stream *stream;
git_odb_object *target_obj;
git_reference *new_ref = NULL;
git_buf ref_name = GIT_BUF_INIT;
assert(oid && buffer);
memset(&tag, 0, sizeof(tag));
if (git_repository_odb__weakptr(&odb, repo) < 0)
return -1;
/* validate the buffer */
if (git_tag__parse_buffer(&tag, buffer, strlen(buffer)) < 0)
return -1;
/* validate the target */
if (git_odb_read(&target_obj, odb, &tag.target) < 0)
goto on_error;
if (tag.type != target_obj->raw.type) {
giterr_set(GITERR_TAG, "The type for the given target is invalid");
goto on_error;
}
error = retrieve_tag_reference_oid(oid, &ref_name, repo, tag.tag_name);
if (error < 0 && error != GIT_ENOTFOUND)
goto on_error;
/* We don't need these objects after this */
git_signature_free(tag.tagger);
git__free(tag.tag_name);
git__free(tag.message);
git_odb_object_free(target_obj);
/** Ensure the tag name doesn't conflict with an already existing
* reference unless overwriting has explictly been requested **/
if (error == 0 && !allow_ref_overwrite) {
giterr_set(GITERR_TAG, "Tag already exists");
return GIT_EEXISTS;
}
/* write the buffer */
if (git_odb_open_wstream(&stream, odb, strlen(buffer), GIT_OBJ_TAG) < 0)
return -1;
stream->write(stream, buffer, strlen(buffer));
error = stream->finalize_write(oid, stream);
stream->free(stream);
if (error < 0) {
git_buf_free(&ref_name);
return -1;
}
error = git_reference_create(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite);
git_reference_free(new_ref);
git_buf_free(&ref_name);
return error;
on_error:
git_signature_free(tag.tagger);
git__free(tag.tag_name);
git__free(tag.message);
git_odb_object_free(target_obj);
return -1;
}
int cmd_rebase(git_repository *repo, int argc, char **argv)
{
int err = GIT_OK;
int rc = EXIT_FAILURE;
git_signature *sig = NULL;
const char *upstream_str;
git_reference *upstream_ref = NULL;
git_annotated_commit *upstream = NULL;
git_reference *branch_ref = NULL;
git_annotated_commit *branch = NULL;
git_rebase *rebase = NULL;
int abort = 0;
int cont = 0;
if (argc < 2)
{
fprintf(stderr, "USAGE: %s <upstream>\n", argv[0]);
fprintf(stderr, "USAGE: %s --abort|--continue\n", argv[0]);
goto out;
}
upstream_str = argv[1];
if (!strcmp(upstream_str, "--abort")) abort = 1;
else if (!strcmp(upstream_str, "--continue")) cont = 1;
if ((err = sgit_get_author_signature(repo, &sig)))
goto out;
if (abort)
{
if ((err = git_rebase_open(&rebase, repo)))
goto out;
if ((err = git_rebase_abort(rebase, sig)))
goto out;
} else
{
git_rebase_operation *oper;
git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
git_rebase_options rebase_opts = GIT_REBASE_OPTIONS_INIT;
checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
if (cont)
{
if ((err = git_rebase_open(&rebase, repo)))
goto out;
} else
{
if ((err = git_reference_dwim(&upstream_ref, repo, upstream_str)))
goto out;
if ((err = git_annotated_commit_from_ref(&upstream, repo, upstream_ref)))
goto out;
if ((err = git_repository_head(&branch_ref,repo)) < 0)
goto out;
if ((err = git_annotated_commit_from_ref(&branch, repo, branch_ref)))
goto out;
if ((err = git_rebase_init(&rebase, repo, branch, upstream, NULL, NULL, NULL)))
goto out;
}
while (!(err = git_rebase_next(&oper, rebase, &checkout_opts)))
{
git_oid oid;
if ((err = git_rebase_commit(&oid, rebase, NULL, sig, NULL, NULL)))
goto out;
}
if (err != GIT_ITEROVER && err != GIT_OK)
goto out;
if ((err = git_rebase_finish(rebase, sig, &rebase_opts)))
goto out;
}
out:
if (err != GIT_OK)
libgit_error();
if (rebase) git_rebase_free(rebase);
if (upstream) git_annotated_commit_free(upstream);
if (upstream_ref) git_reference_free(upstream_ref);
if (branch) git_annotated_commit_free(branch);
if (branch_ref) git_reference_free(branch_ref);
if (sig) git_signature_free(sig);
return rc;
}
void QGit::unstageFiles(QStringList items)
{
QVector<QByteArray> tmpStrList;
git_repository *repo = nullptr;
git_reference *head = nullptr;
git_object *head_commit = nullptr;
git_strarray paths = {nullptr, 0};
int res = 0;
QGitError error;
try {
if (items.count() == 0)
{
throw QGitError();
}
res = git_repository_open(&repo, m_path.absolutePath().toUtf8().constData());
if (res)
{
throw QGitError("git_repository_open", res);
}
paths.count = static_cast<size_t>(items.count());
paths.strings = static_cast<char **>(malloc(sizeof(char *) * static_cast<size_t>(items.count())));
if (paths.strings == nullptr)
{
throw QGitError("malloc", 0);
}
tmpStrList.reserve(items.count());
for(int c = 0; c < items.count(); c++)
{
tmpStrList.append(items.at(c).toUtf8());
paths.strings[c] = const_cast<char *>(tmpStrList.at(c).data());
}
res = git_repository_head(&head, repo);
if (res == 0)
{
res = git_reference_peel(&head_commit, head, GIT_OBJ_COMMIT);
if (res)
{
throw QGitError("git_reference_peel", res);
}
}
res = git_reset_default(repo, head_commit, &paths);
if (res)
{
throw QGitError("git_reset_default", res);
}
} catch(const QGitError &ex) {
error = ex;
}
emit unstageFilesReply(error);
if (paths.strings)
{
free(paths.strings);
paths.strings = nullptr;
}
paths.count = 0;
if (head_commit)
{
git_object_free(head_commit);
head_commit = nullptr;
}
if (head)
{
git_reference_free(head);
head = nullptr;
}
if (repo)
{
git_repository_free(repo);
repo = nullptr;
}
}
void test_network_fetchlocal__prune(void)
{
git_repository *repo;
git_remote *origin;
int callcount = 0;
git_strarray refnames = {0};
git_reference *ref;
git_repository *remote_repo = cl_git_sandbox_init("testrepo.git");
const char *url = cl_git_path_url(git_repository_path(remote_repo));
git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
callbacks.transfer_progress = transfer_cb;
callbacks.payload = &callcount;
cl_set_cleanup(&cleanup_local_repo, "foo");
cl_git_pass(git_repository_init(&repo, "foo", true));
cl_git_pass(git_remote_create(&origin, repo, GIT_REMOTE_ORIGIN, url));
git_remote_set_callbacks(origin, &callbacks);
cl_git_pass(git_remote_fetch(origin, NULL, NULL, NULL));
cl_git_pass(git_reference_list(&refnames, repo));
cl_assert_equal_i(19, (int)refnames.count);
cl_assert(callcount > 0);
git_strarray_free(&refnames);
git_remote_free(origin);
cl_git_pass(git_reference_lookup(&ref, remote_repo, "refs/heads/br2"));
cl_git_pass(git_reference_delete(ref));
git_reference_free(ref);
cl_git_pass(git_remote_lookup(&origin, repo, GIT_REMOTE_ORIGIN));
git_remote_set_callbacks(origin, &callbacks);
cl_git_pass(git_remote_connect(origin, GIT_DIRECTION_FETCH));
cl_git_pass(git_remote_download(origin, NULL));
cl_git_pass(git_remote_prune(origin));
cl_git_pass(git_remote_update_tips(origin, NULL, NULL));
cl_git_pass(git_reference_list(&refnames, repo));
cl_assert_equal_i(18, (int)refnames.count);
git_strarray_free(&refnames);
git_remote_free(origin);
cl_git_pass(git_reference_lookup(&ref, remote_repo, "refs/heads/packed"));
cl_git_pass(git_reference_delete(ref));
git_reference_free(ref);
cl_git_pass(git_remote_lookup(&origin, repo, GIT_REMOTE_ORIGIN));
git_remote_set_callbacks(origin, &callbacks);
cl_git_pass(git_remote_connect(origin, GIT_DIRECTION_FETCH));
cl_git_pass(git_remote_download(origin, NULL));
cl_git_pass(git_remote_prune(origin));
cl_git_pass(git_remote_update_tips(origin, NULL, NULL));
cl_git_pass(git_reference_list(&refnames, repo));
cl_assert_equal_i(17, (int)refnames.count);
git_strarray_free(&refnames);
git_remote_free(origin);
git_repository_free(repo);
}
void test_rebase_merge__commit(void)
{
git_rebase *rebase;
git_reference *branch_ref, *upstream_ref;
git_annotated_commit *branch_head, *upstream_head;
git_rebase_operation *rebase_operation;
git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
git_oid commit_id, tree_id, parent_id;
git_signature *author;
git_commit *commit;
git_reflog *reflog;
const git_reflog_entry *reflog_entry;
checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef"));
cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/master"));
cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref));
cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref));
cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, signature, NULL));
cl_git_pass(git_rebase_next(&rebase_operation, rebase, &checkout_opts));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature,
NULL, NULL));
cl_git_pass(git_commit_lookup(&commit, repo, &commit_id));
git_oid_fromstr(&parent_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00");
cl_assert_equal_i(1, git_commit_parentcount(commit));
cl_assert_equal_oid(&parent_id, git_commit_parent_id(commit, 0));
git_oid_fromstr(&tree_id, "4461379789c777d2a6c1f2ee0e9d6c86731b9992");
cl_assert_equal_oid(&tree_id, git_commit_tree_id(commit));
cl_assert_equal_s(NULL, git_commit_message_encoding(commit));
cl_assert_equal_s("Modification 1 to beef\n", git_commit_message(commit));
cl_git_pass(git_signature_new(&author,
"Edward Thomson", "*****@*****.**", 1405621769, 0-(4*60)));
cl_assert(git_signature__equal(author, git_commit_author(commit)));
cl_assert(git_signature__equal(signature, git_commit_committer(commit)));
/* Make sure the reflogs are updated appropriately */
cl_git_pass(git_reflog_read(&reflog, repo, "HEAD"));
cl_assert(reflog_entry = git_reflog_entry_byindex(reflog, 0));
cl_assert_equal_oid(&parent_id, git_reflog_entry_id_old(reflog_entry));
cl_assert_equal_oid(&commit_id, git_reflog_entry_id_new(reflog_entry));
cl_assert_equal_s("rebase: Modification 1 to beef", git_reflog_entry_message(reflog_entry));
git_reflog_free(reflog);
git_signature_free(author);
git_commit_free(commit);
git_annotated_commit_free(branch_head);
git_annotated_commit_free(upstream_head);
git_reference_free(branch_ref);
git_reference_free(upstream_ref);
git_rebase_free(rebase);
}
int git_rebase_init(
git_rebase **out,
git_repository *repo,
const git_annotated_commit *branch,
const git_annotated_commit *upstream,
const git_annotated_commit *onto,
const git_rebase_options *given_opts)
{
git_rebase *rebase = NULL;
git_annotated_commit *head_branch = NULL;
git_reference *head_ref = NULL;
bool inmemory = (given_opts && given_opts->inmemory);
int error;
assert(repo && (upstream || onto));
*out = NULL;
if (!onto)
onto = upstream;
if ((error = rebase_check_versions(given_opts)) < 0)
goto done;
if (!inmemory) {
if ((error = git_repository__ensure_not_bare(repo, "rebase")) < 0 ||
(error = rebase_ensure_not_in_progress(repo)) < 0 ||
(error = rebase_ensure_not_dirty(repo, true, true, GIT_ERROR)) < 0)
goto done;
}
if (!branch) {
if ((error = git_repository_head(&head_ref, repo)) < 0 ||
(error = git_annotated_commit_from_ref(&head_branch, repo, head_ref)) < 0)
goto done;
branch = head_branch;
}
if (rebase_alloc(&rebase, given_opts) < 0)
return -1;
rebase->repo = repo;
rebase->inmemory = inmemory;
rebase->type = GIT_REBASE_TYPE_MERGE;
if ((error = rebase_init_operations(rebase, repo, branch, upstream, onto)) < 0)
goto done;
if (inmemory)
error = rebase_init_inmemory(rebase, repo, branch, upstream, onto);
else
error = rebase_init_merge(rebase, repo, branch ,upstream, onto);
if (error == 0)
*out = rebase;
done:
git_reference_free(head_ref);
git_annotated_commit_free(head_branch);
if (error < 0) {
rebase_cleanup(rebase);
git_rebase_free(rebase);
}
return error;
}
