int git_branch_is_head( const git_reference *branch) { git_reference *head; bool is_same = false; int error; assert(branch); if (!git_reference_is_branch(branch)) return false; error = git_repository_head(&head, git_reference_owner(branch)); if (error == GIT_EUNBORNBRANCH || error == GIT_ENOTFOUND) return false; if (error < 0) return -1; is_same = strcmp( git_reference_name(branch), git_reference_name(head)) == 0; git_reference_free(head); return is_same; }
void test_refs_reflog_messages__branch_birth(void) { git_signature *sig; git_oid id; git_tree *tree; git_reference *ref; const char *msg; size_t nentries, nentries_after; nentries = reflog_entrycount(g_repo, GIT_HEAD_FILE); cl_git_pass(git_signature_now(&sig, "me", "*****@*****.**")); cl_git_pass(git_repository_head(&ref, g_repo)); cl_git_pass(git_reference_peel((git_object **) &tree, ref, GIT_OBJ_TREE)); cl_git_pass(git_repository_set_head(g_repo, "refs/heads/orphan")); nentries_after = reflog_entrycount(g_repo, GIT_HEAD_FILE); cl_assert_equal_i(nentries, nentries_after); msg = "message 2"; cl_git_pass(git_commit_create(&id, g_repo, "HEAD", sig, sig, NULL, msg, tree, 0, NULL)); cl_assert_equal_i(1, reflog_entrycount(g_repo, "refs/heads/orphan")); nentries_after = reflog_entrycount(g_repo, GIT_HEAD_FILE); cl_assert_equal_i(nentries + 1, nentries_after); git_signature_free(sig); git_tree_free(tree); git_reference_free(ref); }
static int merge_differently_filtered_files(char *files[]) { git_reference *head; git_object *head_object; int error; cl_git_pass(git_repository_head(&head, repo)); cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT)); cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD, NULL)); /* Emulate checkout with a broken or misconfigured filter: modify some * files on-disk and then update the index with the updated file size * and time, as if some filter applied them. These files should not be * treated as dirty since we created them. * * (Make sure to update the index stamp to defeat racy-git protections * trying to sanity check the files in the index; those would rehash the * files, showing them as dirty, the exact mechanism we're trying to avoid.) */ write_files(files); hack_index(files); cl_git_pass(git_index_write(repo_index)); error = merge_branch(); git_object_free(head_object); git_reference_free(head); return error; }
int git_branch_is_head( git_reference *branch) { git_reference *head; bool is_same = false; int error; assert(branch); if (!git_reference_is_branch(branch)) return false; error = git_repository_head(&head, git_reference_owner(branch)); if (error == GIT_EORPHANEDHEAD) return false; if (error < 0) return -1; is_same = strcmp( git_reference_name(branch), git_reference_name(head)) == 0; git_reference_free(head); return is_same; }
/* * Note: this test was flaky prior to fixing #4101 -- run it several * times to get a failure. The issues is that whether the fast * (stat-only) codepath is used inside stash's diff operation depends * on whether files are "racily clean", and there doesn't seem to be * an easy way to force the exact required state. */ void test_stash_save__untracked_regression(void) { git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; const char *paths[] = {"what", "where", "how", "why"}; git_reference *head; git_commit *head_commit; git_buf untracked_dir; const char* workdir = git_repository_workdir(repo); git_buf_init(&untracked_dir, 0); git_buf_printf(&untracked_dir, "%sz", workdir); cl_assert(!p_mkdir(untracked_dir.ptr, 0777)); cl_git_pass(git_repository_head(&head, repo)); cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJ_COMMIT)); opts.checkout_strategy = GIT_CHECKOUT_FORCE; opts.paths.strings = (char **)paths; opts.paths.count = 4; cl_git_pass(git_checkout_tree(repo, (git_object*)head_commit, &opts)); cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_DEFAULT)); assert_commit_message_contains("refs/stash", "WIP on master"); git_reference_free(head); git_commit_free(head_commit); git_buf_dispose(&untracked_dir); }
static void stage_content(char *content[]) { git_reference *head; git_object *head_object; git_buf path = GIT_BUF_INIT; char *filename, *text; size_t i; cl_git_pass(git_repository_head(&head, repo)); cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT)); cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD, NULL)); for (i = 0, filename = content[i], text = content[++i]; filename && text; filename = content[++i], text = content[++i]) { git_buf_clear(&path); cl_git_pass(git_buf_printf(&path, "%s/%s", TEST_REPO_PATH, filename)); cl_git_mkfile(path.ptr, text); cl_git_pass(git_index_add_bypath(repo_index, filename)); } git_object_free(head_object); git_reference_free(head); git_buf_free(&path); }
void CacheGitDirectory::updateRef() { currentGitRef_ = ""; git_repository *repo = NULL; git_reference *head = NULL; git_libgit2_init(); int r = git_repository_open(&repo, gitRepository_.c_str()); if (r != 0) { LOG(INFO) << "Cannot open git repository " << gitRepository_; goto cleanup; } if (git_repository_head_detached(repo)) { LOG(INFO) << "We are in detached state"; goto cleanup; } r = git_repository_head(&head, repo); if (r != 0) { LOG(INFO) << "Cannot get current ref head"; goto cleanup; } currentGitRef_ = git_reference_name(head); LOG(INFO) << "found ref: " << currentGitRef_; cleanup: git_repository_free(repo); git_libgit2_shutdown(); }
void test_refs_revparse__issue_994(void) { git_repository *repo; git_reference *head, *with_at; git_object *target; repo = cl_git_sandbox_init("testrepo.git"); cl_assert_equal_i(GIT_ENOTFOUND, git_revparse_single(&target, repo, "origin/bim_with_3d@11296")); cl_assert_equal_i(GIT_ENOTFOUND, git_revparse_single(&target, repo, "refs/remotes/origin/bim_with_3d@11296")); cl_git_pass(git_repository_head(&head, repo)); cl_git_pass(git_reference_create( &with_at, repo, "refs/remotes/origin/bim_with_3d@11296", git_reference_target(head), 0)); cl_git_pass(git_revparse_single(&target, repo, "origin/bim_with_3d@11296")); git_object_free(target); cl_git_pass(git_revparse_single(&target, repo, "refs/remotes/origin/bim_with_3d@11296")); git_object_free(target); git_reference_free(with_at); git_reference_free(head); cl_git_sandbox_cleanup(); }
void test_repo_head__retrieving_an_unborn_branch_returns_GIT_EUNBORNBRANCH(void) { git_reference *head; make_head_unborn(repo, NON_EXISTING_HEAD); cl_assert_equal_i(GIT_EUNBORNBRANCH, git_repository_head(&head, repo)); }
void test_repo_head__retrieving_a_missing_head_returns_GIT_ENOTFOUND(void) { git_reference *head; delete_head(repo); cl_assert_equal_i(GIT_ENOTFOUND, git_repository_head(&head, repo)); }
int git_revert( git_repository *repo, git_commit *commit, const git_revert_options *given_opts) { git_revert_options opts; git_reference *our_ref = NULL; git_commit *our_commit = NULL; char commit_oidstr[GIT_OID_HEXSZ + 1]; const char *commit_msg; git_buf their_label = GIT_BUF_INIT; git_index *index = NULL; git_indexwriter indexwriter = GIT_INDEXWRITER_INIT; int error; assert(repo && commit); GITERR_CHECK_VERSION(given_opts, GIT_REVERT_OPTIONS_VERSION, "git_revert_options"); if ((error = git_repository__ensure_not_bare(repo, "revert")) < 0) return error; git_oid_fmt(commit_oidstr, git_commit_id(commit)); commit_oidstr[GIT_OID_HEXSZ] = '\0'; if ((commit_msg = git_commit_summary(commit)) == NULL) { error = -1; goto on_error; } if ((error = git_buf_printf(&their_label, "parent of %.7s... %s", commit_oidstr, commit_msg)) < 0 || (error = revert_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 || (error = git_indexwriter_init_for_operation(&indexwriter, repo, &opts.checkout_opts.checkout_strategy)) < 0 || (error = write_revert_head(repo, commit_oidstr)) < 0 || (error = write_merge_msg(repo, commit_oidstr, commit_msg)) < 0 || (error = git_repository_head(&our_ref, repo)) < 0 || (error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJ_COMMIT)) < 0 || (error = git_revert_commit(&index, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 || (error = git_merge__check_result(repo, index)) < 0 || (error = git_merge__append_conflicts_to_merge_msg(repo, index)) < 0 || (error = git_checkout_index(repo, index, &opts.checkout_opts)) < 0 || (error = git_indexwriter_commit(&indexwriter)) < 0) goto on_error; goto done; on_error: revert_state_cleanup(repo); done: git_indexwriter_cleanup(&indexwriter); git_index_free(index); git_commit_free(our_commit); git_reference_free(our_ref); git_buf_free(&their_label); return error; }
static int retrieve_head(git_reference **out, git_repository *repo) { int error = git_repository_head(out, repo); if (error == GIT_EORPHANEDHEAD) return create_error(error, "You do not have the initial commit yet."); return error; }
void test_repo_head__set_head_Attaches_HEAD_to_un_unborn_branch_when_the_branch_doesnt_exist(void) { git_reference *head; cl_git_pass(git_repository_set_head(repo, "refs/heads/doesnt/exist/yet")); cl_assert_equal_i(false, git_repository_head_detached(repo)); cl_assert_equal_i(GIT_EUNBORNBRANCH, git_repository_head(&head, repo)); }
git_reference * repo_head(git_repository * repo){ git_reference * head = NULL; int error = 0; error = git_repository_head(&head, repo); if (error){ fprintf(stderr, "Orphaned Head or not found.\n"); } return head; }
void test_clone_nonetwork__can_checkout_given_branch(void) { g_options.checkout_branch = "test"; cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options)); cl_assert_equal_i(0, git_repository_head_unborn(g_repo)); cl_git_pass(git_repository_head(&g_ref, g_repo)); cl_assert_equal_s(git_reference_name(g_ref), "refs/heads/test"); }
int read_repo(const char *repo_name) { int i; int r; int n; git_repository *repo; git_reference *head; git_oid oid; git_commit *commit; git_tree *tree; git_tree_entry *tree_entry; char out[41]; out[40] = '\0'; // opening the repository r = git_repository_open(&repo, repo_name); if (r) printf("error in opening the repository\n"); printf("Opened the repository successfully.\n"); // obtaining the head r = git_repository_head(&head, repo); if (r) printf("error in obtaining the head\n"); r = git_reference_name_to_oid(&oid, repo, git_reference_name(head)); if (r) printf("error in obtaining the ref id of head\n"); printf("Obtained the head id %s\n", git_oid_tostr(out, 41, &oid)); // obtaining the commit from commit id r = git_commit_lookup(&commit, repo, &oid); if (r) printf("error in obtaining the commit from oid\n"); printf("Obtained the commit.\n"); // obtaining the tree id from the commit oid = *git_commit_tree_oid(commit); // get the tree r = git_tree_lookup(&tree, repo, &oid); if (r) printf("error in looking up the tree for oid\n"); printf("Lookup for tree of oid successful.\n"); n = git_tree_entrycount(tree); for (i=0; i<n; i++) { tree_entry = git_tree_entry_byindex(tree, i); printf("entry >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> %s %s\n", git_tree_entry_name(tree_entry), git_object_type2string(git_tree_entry_type(tree_entry))); } git_repository_free(repo); return 0; }
/** * Get head of repository * * @param repo S4 class git_repository * @return R_NilValue if unborn branch or not found. S4 class * git_branch if not a detached head. S4 class git_commit if detached * head */ SEXP git2r_repository_head(SEXP repo) { int err; SEXP result = R_NilValue; git_commit *commit = NULL; git_reference *reference = NULL; git_repository *repository = NULL; repository= git2r_repository_open(repo); if (!repository) git2r_error(git2r_err_invalid_repository, __func__, NULL); err = git_repository_head(&reference, repository); if (GIT_OK != err) { if (GIT_EUNBORNBRANCH == err || GIT_ENOTFOUND == err) err = GIT_OK; goto cleanup; } if (git_reference_is_branch(reference)) { git_branch_t type = GIT_BRANCH_LOCAL; if (git_reference_is_remote(reference)) type = GIT_BRANCH_REMOTE; PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_branch"))); err = git2r_branch_init(reference, type, repo, result); } else { err = git_commit_lookup( &commit, repository, git_reference_target(reference)); if (GIT_OK != err) goto cleanup; PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_commit"))); git2r_commit_init(commit, repo, result); } cleanup: if (commit) git_commit_free(commit); if (reference) git_reference_free(reference); if (repository) git_repository_free(repository); if (R_NilValue != result) UNPROTECT(1); if (GIT_OK != err) git2r_error(git2r_err_from_libgit2, __func__, giterr_last()->message); return result; }
/* git checkout beef && git rebase --merge --onto master gravy veal */ void test_rebase_setup__merge_onto_upstream_and_branch(void) { git_rebase *rebase; git_reference *upstream_ref, *branch_ref, *onto_ref; git_annotated_commit *upstream_head, *branch_head, *onto_head; git_reference *head; git_commit *head_commit; git_oid head_id; git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT; checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE; cl_assert_equal_i(GIT_REPOSITORY_STATE_NONE, git_repository_state(repo)); cl_git_pass(git_repository_set_head(repo, "refs/heads/beef")); cl_git_pass(git_checkout_head(repo, &checkout_opts)); cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/veal")); cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/gravy")); cl_git_pass(git_reference_lookup(&onto_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_annotated_commit_from_ref(&onto_head, repo, onto_ref)); cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, onto_head, NULL)); git_oid_fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00"); cl_git_pass(git_repository_head(&head, repo)); cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT)); cl_assert_equal_oid(&head_id, git_commit_id(head_commit)); cl_assert_equal_file("f87d14a4a236582a0278a916340a793714256864\n", 41, "rebase/.git/ORIG_HEAD"); cl_assert_equal_i(GIT_REPOSITORY_STATE_REBASE_MERGE, git_repository_state(repo)); cl_assert_equal_file("3e8989b5a16d5258c935d998ef0e6bb139cc4757\n", 41, "rebase/.git/rebase-merge/cmt.1"); cl_assert_equal_file("4cacc6f6e740a5bc64faa33e04b8ef0733d8a127\n", 41, "rebase/.git/rebase-merge/cmt.2"); cl_assert_equal_file("f87d14a4a236582a0278a916340a793714256864\n", 41, "rebase/.git/rebase-merge/cmt.3"); cl_assert_equal_file("3\n", 2, "rebase/.git/rebase-merge/end"); cl_assert_equal_file("efad0b11c47cb2f0220cbd6f5b0f93bb99064b00\n", 41, "rebase/.git/rebase-merge/onto"); cl_assert_equal_file("master\n", 7, "rebase/.git/rebase-merge/onto_name"); cl_assert_equal_file("f87d14a4a236582a0278a916340a793714256864\n", 41, "rebase/.git/rebase-merge/orig-head"); git_commit_free(head_commit); git_reference_free(head); git_annotated_commit_free(upstream_head); git_annotated_commit_free(branch_head); git_annotated_commit_free(onto_head); git_reference_free(upstream_ref); git_reference_free(branch_ref); git_reference_free(onto_ref); git_rebase_free(rebase); }
int git_cherry_pick( git_repository *repo, git_commit *commit, const git_cherry_pick_options *given_opts) { git_cherry_pick_options opts; git_reference *our_ref = NULL; git_commit *our_commit = NULL; char commit_oidstr[GIT_OID_HEXSZ + 1]; const char *commit_msg, *commit_summary; git_buf their_label = GIT_BUF_INIT; git_index *index_new = NULL; int error = 0; assert(repo && commit); GITERR_CHECK_VERSION(given_opts, GIT_CHERRY_PICK_OPTIONS_VERSION, "git_cherry_pick_options"); if ((error = git_repository__ensure_not_bare(repo, "cherry-pick")) < 0) return error; if ((commit_msg = git_commit_message(commit)) == NULL || (commit_summary = git_commit_summary(commit)) == NULL) { error = -1; goto on_error; } git_oid_nfmt(commit_oidstr, sizeof(commit_oidstr), git_commit_id(commit)); if ((error = write_merge_msg(repo, commit_msg)) < 0 || (error = git_buf_printf(&their_label, "%.7s... %s", commit_oidstr, commit_summary)) < 0 || (error = cherry_pick_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 || (error = write_cherry_pick_head(repo, commit_oidstr)) < 0 || (error = git_repository_head(&our_ref, repo)) < 0 || (error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJ_COMMIT)) < 0 || (error = git_cherry_pick_commit(&index_new, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 || (error = git_merge__check_result(repo, index_new)) < 0 || (error = git_merge__append_conflicts_to_merge_msg(repo, index_new)) < 0 || (error = git_checkout_index(repo, index_new, &opts.checkout_opts)) < 0) goto on_error; goto done; on_error: cherry_pick_state_cleanup(repo); done: git_index_free(index_new); git_commit_free(our_commit); git_reference_free(our_ref); git_buf_free(&their_label); return error; }
void test_repo_head__set_head_Attaches_HEAD_when_the_reference_points_to_a_branch(void) { git_reference *head; cl_git_pass(git_repository_set_head(repo, "refs/heads/br2")); cl_assert_equal_i(false, git_repository_head_detached(repo)); cl_git_pass(git_repository_head(&head, repo)); cl_assert_equal_s("refs/heads/br2", git_reference_name(head)); git_reference_free(head); }
void QGit::currentBranch() { git_repository *repo = nullptr; git_reference *ref = nullptr; const char *branch = nullptr; int res = 0; QGitError error; QString name; try { res = git_repository_open(&repo, m_path.absolutePath().toUtf8().constData()); if (res) { throw QGitError("git_repository_open", res); } res = git_repository_head(&ref, repo); if (res) { throw QGitError("git_repository_head", res); } res = git_branch_name(&branch, ref); if (res) { throw QGitError("git_branch_name", res); } name = branch; } catch(const QGitError &ex) { error = ex; } emit currentBranchReply(name, error); if (ref) { git_reference_free(ref); ref = nullptr; } if (repo) { git_repository_free(repo); repo = nullptr; } }
void test_refs_branches_move__moving_the_branch_pointed_at_by_HEAD_updates_HEAD(void) { git_reference *branch; git_reference *new_branch; cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/master")); cl_git_pass(git_branch_move(&new_branch, branch, "master2", 0)); git_reference_free(branch); git_reference_free(new_branch); cl_git_pass(git_repository_head(&branch, repo)); cl_assert_equal_s("refs/heads/master2", git_reference_name(branch)); git_reference_free(branch); }
static void assert_head_is_correctly_detached(void) { git_reference *head; git_object *commit; cl_assert_equal_i(true, git_repository_head_detached(repo)); cl_git_pass(git_repository_head(&head, repo)); cl_git_pass(git_object_lookup(&commit, repo, git_reference_target(head), GIT_OBJECT_COMMIT)); git_object_free(commit); git_reference_free(head); }
int git_rebase_finish( git_rebase *rebase, const git_signature *signature, const git_rebase_options *given_opts) { git_rebase_options opts; git_reference *terminal_ref = NULL, *branch_ref = NULL, *head_ref = NULL; git_commit *terminal_commit = NULL; git_buf branch_msg = GIT_BUF_INIT, head_msg = GIT_BUF_INIT; char onto[GIT_OID_HEXSZ]; int error; assert(rebase); GITERR_CHECK_VERSION(given_opts, GIT_REBASE_OPTIONS_VERSION, "git_rebase_options"); if ((error = rebase_normalize_opts(rebase->repo, &opts, given_opts)) < 0) goto done; git_oid_fmt(onto, &rebase->onto_id); if ((error = git_buf_printf(&branch_msg, "rebase finished: %s onto %.*s", rebase->orig_head_name, GIT_OID_HEXSZ, onto)) < 0 || (error = git_buf_printf(&head_msg, "rebase finished: returning to %s", rebase->orig_head_name)) < 0 || (error = git_repository_head(&terminal_ref, rebase->repo)) < 0 || (error = git_reference_peel((git_object **)&terminal_commit, terminal_ref, GIT_OBJ_COMMIT)) < 0 || (error = git_reference_create_matching(&branch_ref, rebase->repo, rebase->orig_head_name, git_commit_id(terminal_commit), 1, &rebase->orig_head_id, branch_msg.ptr)) < 0 || (error = git_reference_symbolic_create(&head_ref, rebase->repo, GIT_HEAD_FILE, rebase->orig_head_name, 1, head_msg.ptr)) < 0 || (error = rebase_copy_notes(rebase, signature, &opts)) < 0) goto done; error = rebase_cleanup(rebase); done: git_buf_free(&head_msg); git_buf_free(&branch_msg); git_commit_free(terminal_commit); git_reference_free(head_ref); git_reference_free(branch_ref); git_reference_free(terminal_ref); rebase_opts_free(&opts); return error; }
/* git checkout beef && git rebase --merge --onto `git rev-parse master` * `git rev-parse veal` `git rev-parse gravy` */ void test_rebase_setup__merge_onto_upstream_and_branch_by_id(void) { git_rebase *rebase; git_oid upstream_id, branch_id, onto_id; git_annotated_commit *upstream_head, *branch_head, *onto_head; git_reference *head; git_commit *head_commit; git_oid head_id; git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT; checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE; cl_assert_equal_i(GIT_REPOSITORY_STATE_NONE, git_repository_state(repo)); cl_git_pass(git_repository_set_head(repo, "refs/heads/beef")); cl_git_pass(git_checkout_head(repo, &checkout_opts)); cl_git_pass(git_oid_fromstr(&upstream_id, "f87d14a4a236582a0278a916340a793714256864")); cl_git_pass(git_oid_fromstr(&branch_id, "d616d97082eb7bb2dc6f180a7cca940993b7a56f")); cl_git_pass(git_oid_fromstr(&onto_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00")); cl_git_pass(git_annotated_commit_lookup(&upstream_head, repo, &upstream_id)); cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id)); cl_git_pass(git_annotated_commit_lookup(&onto_head, repo, &onto_id)); cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, onto_head, NULL)); git_oid_fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00"); cl_git_pass(git_repository_head(&head, repo)); cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT)); cl_assert_equal_oid(&head_id, git_commit_id(head_commit)); cl_assert_equal_file("d616d97082eb7bb2dc6f180a7cca940993b7a56f\n", 41, "rebase/.git/ORIG_HEAD"); cl_assert_equal_i(GIT_REPOSITORY_STATE_REBASE_MERGE, git_repository_state(repo)); cl_assert_equal_file("d616d97082eb7bb2dc6f180a7cca940993b7a56f\n", 41, "rebase/.git/rebase-merge/cmt.1"); cl_assert_equal_file("1\n", 2, "rebase/.git/rebase-merge/end"); cl_assert_equal_file("efad0b11c47cb2f0220cbd6f5b0f93bb99064b00\n", 41, "rebase/.git/rebase-merge/onto"); cl_assert_equal_file("efad0b11c47cb2f0220cbd6f5b0f93bb99064b00\n", 41, "rebase/.git/rebase-merge/onto_name"); cl_assert_equal_file("d616d97082eb7bb2dc6f180a7cca940993b7a56f\n", 41, "rebase/.git/rebase-merge/orig-head"); git_commit_free(head_commit); git_reference_free(head); git_annotated_commit_free(upstream_head); git_annotated_commit_free(branch_head); git_annotated_commit_free(onto_head); git_rebase_free(rebase); }
void GitRepository::push() { git_repository* repo = repository(); const char* remote_name = "origin"; git_auto<git_remote> remote; git_eval(git_remote_lookup(&remote, repo, remote_name)); git_eval(git_remote_connect(remote, GIT_DIRECTION_PUSH, NULL, NULL)); git_auto<git_reference> head; git_eval(git_repository_head(&head, repo)); QString refname = QString("+%1:%1").arg(git_reference_name(head)); git_eval(git_remote_add_push(repo, remote_name, refname.toLatin1())); git_eval(git_remote_upload(remote, NULL, NULL)); }
static int prepare_index(git_index *index, char* msg){ git_oid index_tree; git_tree *head_obj; git_reference *head; char tree_str[GIT_OID_HEXSZ+1], parent_str[GIT_OID_HEXSZ+1]; // Get the head OID git_repository_head(&head, repo); git_reference_peel((git_object**)&head_obj, head, GIT_OBJ_COMMIT); git_oid_tostr(parent_str, GIT_OID_HEXSZ+1, git_tree_id(head_obj)); git_reference_free(head); git_object_free((git_object*)head_obj); // Write the coin // TODO: Use C for this? system("perl -i -pe 's/(null:)(\\d+)/$1 . ($2+1)/e' LEDGER.txt"); system("grep -q \"null\" LEDGER.txt || echo \"null:1\" >> LEDGER.txt"); // Update the index check_lg2(git_index_read(index, 0), "Could not re-read index from disk", NULL); check_lg2(git_index_add_bypath(index, "LEDGER.txt"), "Could not add to index", "LEDGER.txt"); // Write the index and get the tree OID git_index_write_tree(&index_tree, index); git_oid_tostr(tree_str, GIT_OID_HEXSZ+1, &index_tree); snprintf(msg, BUFFER_LENGTH, "commit %d%c" "tree %s\n" "parent %s\n" "author null <*****@*****.**> %d +0000\n" "committer null <*****@*****.**> %d +0000\n" "\n" "coins now" "\x01\x01\x01\x01" "\x01\x01\x01\x01" "\x01\x01\x01", // Align 32 bit words on GPU MSG_LENGTH, 0, tree_str, parent_str, (int)time(NULL), (int)time(NULL)); pad_message(msg, COMMIT_LENGTH, BUFFER_LENGTH); return 0; }
void test_merge_workdir_dirty__unstaged_deletes_maintained(void) { git_reference *head; git_object *head_object; cl_git_pass(git_repository_head(&head, repo)); cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT)); cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD, NULL)); cl_git_pass(p_unlink("merge-resolve/unchanged.txt")); cl_git_pass(merge_branch()); git_object_free(head_object); git_reference_free(head); }
Reference Repository::head() const { git_reference * head; switch (auto error = git_repository_head(&head, repo_)) { case GIT_EUNBORNBRANCH: throw non_existing_branch_error(); case GIT_ENOTFOUND: throw missing_head_error(); default: if (error == 0) return Reference(head); else throw unknown_get_current_branch_error(); } }
int git_repository_head_orphan(git_repository *repo) { git_reference *ref = NULL; int error; error = git_repository_head(&ref, repo); git_reference_free(ref); if (error == GIT_ENOTFOUND) return 1; if (error < 0) return -1; return 0; }