// 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_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); cl_git_pass(git_reference_symbolic_set_target(head, branch_name)); 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(committer); 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)); }
/* Test that we can read a commit with no note fails */ void test_notes_notes__attempt_to_read_a_note_from_a_commit_with_no_note_fails(void) { git_oid oid, notes_commit_oid; git_commit *notes_commit; git_note *note; cl_git_pass(git_oid_fromstr(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045")); cl_git_pass(git_note_commit_create(¬es_commit_oid, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 1)); git_commit_lookup(¬es_commit, _repo, ¬es_commit_oid); cl_git_pass(git_note_commit_remove(¬es_commit_oid, _repo, notes_commit, _sig, _sig, &oid)); git_commit_free(notes_commit); git_commit_lookup(¬es_commit, _repo, ¬es_commit_oid); cl_assert(notes_commit); cl_git_fail_with(GIT_ENOTFOUND, git_note_commit_read(¬e, _repo, notes_commit, &oid)); git_commit_free(notes_commit); }
int git_commit_parent( git_commit **parent, const git_commit *commit, unsigned int n) { const git_oid *parent_id; assert(commit); parent_id = git_commit_parent_id(commit, n); if (parent_id == NULL) { giterr_set(GITERR_INVALID, "Parent %u does not exist", n); return GIT_ENOTFOUND; } return git_commit_lookup(parent, commit->object.repo, parent_id); }
void test_checkout_tree__doesnt_write_unrequested_files_to_worktree(void) { git_oid master_oid; git_oid chomped_oid; git_commit* p_master_commit; git_commit* p_chomped_commit; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; git_oid_fromstr(&master_oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); git_oid_fromstr(&chomped_oid, "e90810b8df3e80c413d903f631643c716887138d"); cl_git_pass(git_commit_lookup(&p_master_commit, g_repo, &master_oid)); cl_git_pass(git_commit_lookup(&p_chomped_commit, g_repo, &chomped_oid)); /* GIT_CHECKOUT_NONE should not add any file to the working tree from the * index as it is supposed to be a dry run. */ opts.checkout_strategy = GIT_CHECKOUT_NONE; git_checkout_tree(g_repo, (git_object*)p_chomped_commit, &opts); cl_assert_equal_i(false, git_path_isfile("testrepo/readme.txt")); git_commit_free(p_master_commit); git_commit_free(p_chomped_commit); }
int cmd_log(git_repository *repo, int argc, char **argv) { int err = 0; int rc; git_revwalk *walk; git_oid oid; git_reference *revision_ref = NULL; git_object *revision_obj = NULL; rc = EXIT_FAILURE; git_revwalk_new(&walk,repo); if (argc > 1) { if ((err = git_reference_dwim(&revision_ref, repo, argv[1]))) goto out; if ((err = git_reference_peel(&revision_obj, revision_ref, GIT_OBJ_ANY))) goto out; if ((err = git_revwalk_push(walk, git_object_id(revision_obj)))) goto out; } else { git_revwalk_push_head(walk); } while ((git_revwalk_next(&oid, walk)) == 0) { struct git_commit *wcommit; if (git_commit_lookup(&wcommit, repo, &oid) != 0) continue; print_commit(wcommit,"commit %C\nAuthor: %a\nDate: %d\n\n%m\n"); git_commit_free(wcommit); } git_revwalk_free(walk); rc = EXIT_SUCCESS; out: if (err != GIT_OK) libgit_error(); if (revision_obj) git_object_free(revision_obj); if (revision_ref) git_reference_free(revision_ref); return rc; }
// ReadTree is/must only be executed on an empty list int CGitHeadFileList::ReadTree() { CAutoWriteLock lock(&m_SharedMutex); CStringA gitdir = CUnicodeUtils::GetMulti(m_Gitdir, CP_UTF8); git_repository *repository = NULL; git_commit *commit = NULL; git_tree * tree = NULL; int ret = 0; ATLASSERT(this->empty()); do { ret = git_repository_open(&repository, gitdir); if(ret) break; ret = git_commit_lookup(&commit, repository, (const git_oid*)m_Head.m_hash); if(ret) break; ret = git_commit_tree(&tree, commit); if(ret) break; ret = ReadTreeRecursive(*repository, tree,"", CGitHeadFileList::CallBack,this); if(ret) break; std::sort(this->begin(), this->end(), SortTree); this->m_TreeHash = (char*)(git_commit_id(commit)->id); } while(0); if (tree) git_tree_free(tree); if (commit) git_commit_free(commit); if (repository) git_repository_free(repository); if (ret) { clear(); m_LastModifyTimeHead = 0; } return ret; }
void test_apply_both__honors_crlf_attributes(void) { git_diff *diff; git_oid oid; git_commit *commit; const char *diff_file = DIFF_MODIFY_TWO_FILES; struct merge_index_entry index_expected[] = { { 0100644, "ffb36e513f5fdf8a6ba850a20142676a2ac4807d", 0, "asparagus.txt" }, { 0100644, "68f6182f4c85d39e1309d97c7e456156dc9c0096", 0, "beef.txt" }, { 0100644, "4b7c5650008b2e747fe1809eeb5a1dde0e80850a", 0, "bouilli.txt" }, { 0100644, "c4e6cca3ec6ae0148ed231f97257df8c311e015f", 0, "gravy.txt" }, { 0100644, "68af1fc7407fd9addf1701a87eb1c95c7494c598", 0, "oyster.txt" }, { 0100644, "a7b066537e6be7109abfe4ff97b675d4e077da20", 0, "veal.txt" }, }; size_t index_expected_cnt = sizeof(index_expected) / sizeof(struct merge_index_entry); struct merge_index_entry workdir_expected[] = { { 0100644, "176a458f94e0ea5272ce67c36bf30b6be9caf623", 0, ".gitattributes" }, { 0100644, "ffb36e513f5fdf8a6ba850a20142676a2ac4807d", 0, "asparagus.txt" }, { 0100644, "68f6182f4c85d39e1309d97c7e456156dc9c0096", 0, "beef.txt" }, { 0100644, "4b7c5650008b2e747fe1809eeb5a1dde0e80850a", 0, "bouilli.txt" }, { 0100644, "c4e6cca3ec6ae0148ed231f97257df8c311e015f", 0, "gravy.txt" }, { 0100644, "68af1fc7407fd9addf1701a87eb1c95c7494c598", 0, "oyster.txt" }, { 0100644, "a7b066537e6be7109abfe4ff97b675d4e077da20", 0, "veal.txt" }, }; size_t workdir_expected_cnt = sizeof(workdir_expected) / sizeof(struct merge_index_entry); cl_git_mkfile("merge-recursive/.gitattributes", "* text=auto\n"); cl_git_rmfile("merge-recursive/asparagus.txt"); cl_git_rmfile("merge-recursive/veal.txt"); git_oid_fromstr(&oid, "539bd011c4822c560c1d17cab095006b7a10f707"); cl_git_pass(git_commit_lookup(&commit, repo, &oid)); cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL)); git_commit_free(commit); cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file))); cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL)); validate_apply_index(repo, index_expected, index_expected_cnt); validate_apply_workdir(repo, workdir_expected, workdir_expected_cnt); git_diff_free(diff); }
void test_checkout_icase__ignores_unstaged_casechange(void) { git_reference *orig_ref, *br2_ref; git_commit *orig, *br2; git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT; checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE; cl_git_pass(git_reference_lookup_resolved(&orig_ref, repo, "HEAD", 100)); cl_git_pass(git_commit_lookup(&orig, repo, git_reference_target(orig_ref))); cl_git_pass(git_reset(repo, (git_object *)orig, GIT_RESET_HARD, NULL)); cl_rename("testrepo/branch_file.txt", "testrepo/Branch_File.txt"); cl_git_pass(git_reference_lookup_resolved(&br2_ref, repo, "refs/heads/br2", 100)); cl_git_pass(git_commit_lookup(&br2, repo, git_reference_target(br2_ref))); cl_git_pass(git_checkout_tree(repo, (const git_object *)br2, &checkout_opts)); git_commit_free(orig); git_commit_free(br2); git_reference_free(orig_ref); git_reference_free(br2_ref); }
/* git reset --hard 72333f47d4e83616630ff3b0ffe4c0faebcc3c45 * git revert --no-commit d1d403d22cbe24592d725f442835cf46fe60c8ac */ void test_revert_workdir__conflict_use_ours(void) { git_commit *head, *commit; git_oid head_oid, revert_oid; git_revert_options opts = GIT_REVERT_OPTIONS_INIT; struct merge_index_entry merge_index_entries[] = { { 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" }, { 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" }, { 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" }, { 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" }, }; struct merge_index_entry merge_filesystem_entries[] = { { 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" }, { 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" }, { 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" }, { 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" }, }; opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS; git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45"); cl_git_pass(git_commit_lookup(&head, repo, &head_oid)); cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL)); git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac"); cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid)); cl_git_pass(git_revert(repo, commit, &opts)); cl_assert(merge_test_index(repo_index, merge_index_entries, 4)); cl_assert(merge_test_workdir(repo, merge_filesystem_entries, 4)); git_commit_free(commit); git_commit_free(head); }
/* git reset --hard 5acdc74af27172ec491d213ee36cea7eb9ef2579 * git revert HEAD */ void test_revert_workdir__merge_fails_without_mainline_specified(void) { git_commit *head; git_oid head_oid; git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579"); cl_git_pass(git_commit_lookup(&head, repo, &head_oid)); cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL)); cl_must_fail(git_revert(repo, head, NULL)); cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG")); cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/REVERT_HEAD")); git_commit_free(head); }
void test_merge_workdir_simple__directory_file(void) { git_reference *head; git_oid their_oids[1], head_commit_id; git_merge_head *their_heads[1]; git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT; git_commit *head_commit; struct merge_index_entry merge_index_entries[] = { { 0100644, "49130a28ef567af9a6a6104c38773fedfa5f9742", 2, "dir-10" }, { 0100644, "6c06dcd163587c2cc18be44857e0b71116382aeb", 3, "dir-10" }, { 0100644, "43aafd43bea779ec74317dc361f45ae3f532a505", 0, "dir-6" }, { 0100644, "a031a28ae70e33a641ce4b8a8f6317f1ab79dee4", 3, "dir-7" }, { 0100644, "5012fd565b1393bdfda1805d4ec38ce6619e1fd1", 1, "dir-7/file.txt" }, { 0100644, "a5563304ddf6caba25cb50323a2ea6f7dbfcadca", 2, "dir-7/file.txt" }, { 0100644, "e9ad6ec3e38364a3d07feda7c4197d4d845c53b5", 0, "dir-8" }, { 0100644, "3ef4d30382ca33fdeba9fda895a99e0891ba37aa", 2, "dir-9" }, { 0100644, "fc4c636d6515e9e261f9260dbcf3cc6eca97ea08", 1, "dir-9/file.txt" }, { 0100644, "76ab0e2868197ec158ddd6c78d8a0d2fd73d38f9", 3, "dir-9/file.txt" }, { 0100644, "5c2411f8075f48a6b2fdb85ebc0d371747c4df15", 0, "file-1/new" }, { 0100644, "a39a620dae5bc8b4e771cd4d251b7d080401a21e", 1, "file-2" }, { 0100644, "d963979c237d08b6ba39062ee7bf64c7d34a27f8", 2, "file-2" }, { 0100644, "5c341ead2ba6f2af98ce5ec3fe84f6b6d2899c0d", 0, "file-2/new" }, { 0100644, "9efe7723802d4305142eee177e018fee1572c4f4", 0, "file-3/new" }, { 0100644, "bacac9b3493509aa15e1730e1545fc0919d1dae0", 1, "file-4" }, { 0100644, "7663fce0130db092936b137cabd693ec234eb060", 3, "file-4" }, { 0100644, "e49f917b448d1340b31d76e54ba388268fd4c922", 0, "file-4/new" }, { 0100644, "cab2cf23998b40f1af2d9d9a756dc9e285a8df4b", 2, "file-5/new" }, { 0100644, "f5504f36e6f4eb797a56fc5bac6c6c7f32969bf2", 3, "file-5/new" }, }; cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, GIT_REFS_HEADS_DIR OURS_DIRECTORY_FILE, 1, NULL, NULL)); cl_git_pass(git_reference_name_to_id(&head_commit_id, repo, GIT_HEAD_FILE)); cl_git_pass(git_commit_lookup(&head_commit, repo, &head_commit_id)); cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD, NULL, NULL)); cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_DIRECTORY_FILE)); cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0])); merge_opts.file_favor = 0; cl_git_pass(git_merge(repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL)); cl_assert(merge_test_index(repo_index, merge_index_entries, 20)); git_reference_free(head); git_commit_free(head_commit); git_merge_head_free(their_heads[0]); }
/* Helper to get the latest commit of the specified file */ int git_show_last_commit(char *filename) { git_oid oid; git_commit *commit = NULL; /* Set up pathspec. */ git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT; diffopts.pathspec.strings = &filename; diffopts.pathspec.count = 1; /* Use the revwalker to traverse the history. */ check_lg2(git_revwalk_push_ref(s.walker, s.ref), "Could not find repository reference", NULL); for (; !git_revwalk_next(&oid, s.walker); git_commit_free(commit)) { check_lg2(git_commit_lookup(&commit, s.repo, &oid), "Failed to look up commit", NULL); int parents = (int)git_commit_parentcount(commit); int unmatched = parents; if (parents == 0) { git_tree *tree; git_pathspec *ps; check_lg2(git_commit_tree(&tree, commit), "Get tree", NULL); check_lg2(git_pathspec_new(&ps, &diffopts.pathspec), "Building pathspec", NULL); if (git_pathspec_match_tree( NULL, tree, GIT_PATHSPEC_NO_MATCH_ERROR, ps) != 0) unmatched = 1; git_pathspec_free(ps); git_tree_free(tree); } else { int i; for (i = 0; i < parents; ++i) { if (match_with_parent(commit, i, &diffopts)) unmatched--; } } if (unmatched > 0) continue; print_commit(commit); git_commit_free(commit); break; } git_revwalk_reset(s.walker); return 0; }
git_commit *git_commit_parse(git_revpool *pool, const git_oid *id) { git_commit *commit = NULL; if ((commit = git_commit_lookup(pool, id)) == NULL) return NULL; if (git_commit_parse_existing(commit) < 0) goto error_cleanup; return commit; error_cleanup: free(commit); return NULL; }
static struct git_commit *get_last_commit() { int rc; git_commit * commit = NULL; git_oid oid_parent_commit; rc = git_reference_name_to_id( &oid_parent_commit, repo, "HEAD"); if (0 == rc) { rc = git_commit_lookup( &commit, repo, &oid_parent_commit); if (0 == rc) { return commit; } } return NULL; }
static void fill_index_wth_head_entries(git_repository *repo, git_index *index) { git_oid oid; git_commit *commit; git_tree *tree; cl_git_pass(git_reference_name_to_oid(&oid, repo, "HEAD")); cl_git_pass(git_commit_lookup(&commit, repo, &oid)); cl_git_pass(git_commit_tree(&tree, commit)); cl_git_pass(git_index_read_tree(index, tree)); cl_git_pass(git_index_write(index)); git_tree_free(tree); git_commit_free(commit); }
static void diff_stats_from_commit_oid( git_diff_stats **stats, const char *oidstr, bool rename) { git_oid oid; git_commit *commit; git_diff *diff; git_oid_fromstr(&oid, oidstr); cl_git_pass(git_commit_lookup(&commit, _repo, &oid)); cl_git_pass(git_diff__commit(&diff, _repo, commit, NULL)); if (rename) cl_git_pass(git_diff_find_similar(diff, NULL)); cl_git_pass(git_diff_get_stats(stats, diff)); git_diff_free(diff); git_commit_free(commit); }
/** * Init slots in S3 class git_stash * * @param source The commit oid of the stashed state. * @param repository The repository * @param repo S3 class git_repository that contains the stash * @param dest S3 class git_stash to initialize * @return int 0 on success, or an error code. */ int git2r_stash_init( const git_oid *source, git_repository *repository, SEXP repo, SEXP dest) { int error; git_commit *commit = NULL; error = git_commit_lookup(&commit, repository, source); if (error) return error; git2r_commit_init(commit, repo, dest); git_commit_free(commit); return 0; }
/** * Invoked 'callback' for each ID in the MERGE_HEAD file. * * @param oid The id of the merge head * @param payload Payload data passed to 'git_repository_mergehead_foreach' * @return 0 */ static int git2r_repository_mergehead_foreach_cb( const git_oid *oid, void *payload) { int err = 0; git2r_merge_head_cb_data *cb_data = (git2r_merge_head_cb_data*)payload; if (cb_data->parents) err = git_commit_lookup( &(cb_data->parents[cb_data->n]), cb_data->repository, oid); cb_data->n += 1; return err; }
Commit::Commit(Repository *repo, Sha *commitSha) : Sha (commitSha) { this->repo = repo; try { gitTest(git_commit_lookup(&commit, repo->getInternalRepo(), sha)); } catch (GitException e) { commitLookupExecption (e); } this->graph = nullptr; this->commitTree = nullptr; populateParentSha(); }
static int rebase_init_operations( git_rebase *rebase, git_repository *repo, const git_annotated_commit *branch, const git_annotated_commit *upstream, const git_annotated_commit *onto) { git_revwalk *revwalk = NULL; git_commit *commit; git_oid id; bool merge; git_rebase_operation *operation; int error; if (!upstream) upstream = onto; if ((error = git_revwalk_new(&revwalk, rebase->repo)) < 0 || (error = git_revwalk_push(revwalk, git_annotated_commit_id(branch))) < 0 || (error = git_revwalk_hide(revwalk, git_annotated_commit_id(upstream))) < 0) goto done; git_revwalk_sorting(revwalk, GIT_SORT_REVERSE | GIT_SORT_TIME); while ((error = git_revwalk_next(&id, revwalk)) == 0) { if ((error = git_commit_lookup(&commit, repo, &id)) < 0) goto done; merge = (git_commit_parentcount(commit) > 1); git_commit_free(commit); if (merge) continue; operation = git_array_alloc(rebase->operations); operation->type = GIT_REBASE_OPERATION_PICK; git_oid_cpy((git_oid *)&operation->id, &id); } error = 0; done: git_revwalk_free(revwalk); return error; }
void test_object_tree_read__largefile(void) { git_reference *ref; git_commit *commit; git_tree *tree; git_oid oid; const git_tree_entry *entry; git_object *object; git_buf file = GIT_BUF_INIT; int fd; git_index *idx; if (!cl_is_env_set("GITTEST_INVASIVE_FS_SIZE")) cl_skip(); cl_git_pass(git_reference_lookup(&ref, g_repo, "refs/heads/master")); cl_git_pass(git_repository_index(&idx, g_repo)); cl_git_pass(git_buf_puts(&file, git_repository_workdir(g_repo))); cl_git_pass(git_buf_joinpath(&file, file.ptr, BIGFILE)); fd = p_open(git_buf_cstr(&file), O_CREAT|O_RDWR, 0644); cl_assert_(fd >= 0, "invalid file descriptor"); cl_must_pass(p_fallocate(fd, 0, BIGFILE_SIZE)); cl_must_pass(p_close(fd)); cl_git_pass(git_index_add_bypath(idx, BIGFILE)); cl_repo_commit_from_index(&oid, g_repo, NULL, 0, "bigfile"); cl_git_pass(git_commit_lookup(&commit, g_repo, &oid)); cl_git_pass(git_commit_tree(&tree, commit)); entry = git_tree_entry_byname(tree, BIGFILE); cl_assert_(entry, "entry was NULL"); cl_git_pass(git_tree_entry_to_object(&object, g_repo, entry)); git_buf_dispose(&file); git_object_free(object); git_tree_free(tree); git_index_free(idx); git_commit_free(commit); git_reference_free(ref); }
void test_odb_alternates__chained(void) { git_commit *commit; git_oid oid; /* Set the alternate A -> testrepo.git */ init_linked_repo(paths[0], cl_fixture("testrepo.git")); /* Set the alternate B -> A */ init_linked_repo(paths[1], paths[0]); /* Now load B and see if we can find an object from testrepo.git */ cl_git_pass(git_repository_open(&repo, paths[1])); git_oid_fromstr(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); cl_git_pass(git_commit_lookup(&commit, repo, &oid)); git_commit_free(commit); git_repository_free(repo); }
MasterlistInfo Masterlist::GetInfo(const boost::filesystem::path& path, bool shortID) { // Compare HEAD and working copy, and get revision info. GitHelper git; MasterlistInfo info; git.SetErrorMessage((boost::format(translate("An error occurred while trying to read the local masterlist's version. If this error happens again, try deleting the \".git\" folder in %1%.")) % path.parent_path().string()).str()); if (!fs::exists(path)) { BOOST_LOG_TRIVIAL(info) << "Unknown masterlist revision: No masterlist present."; throw FileAccessError(translate("N/A: No masterlist present")); } else if (!git.IsRepository(path.parent_path())) { BOOST_LOG_TRIVIAL(info) << "Unknown masterlist revision: Git repository missing."; throw GitStateError(translate("Unknown: Git repository missing")); } BOOST_LOG_TRIVIAL(debug) << "Existing repository found, attempting to open it."; git.Call(git_repository_open(&git.GetData().repo, path.parent_path().string().c_str())); //Need to get the HEAD object, because the individual file has a different SHA. BOOST_LOG_TRIVIAL(info) << "Getting the Git object for the tree at HEAD."; git.Call(git_revparse_single(&git.GetData().object, git.GetData().repo, "HEAD")); BOOST_LOG_TRIVIAL(trace) << "Generating hex string for Git object ID."; if (shortID) { git.Call(git_object_short_id(&git.GetData().buffer, git.GetData().object)); info.revision_id = git.GetData().buffer.ptr; } else { char c_rev[GIT_OID_HEXSZ + 1]; info.revision_id = git_oid_tostr(c_rev, GIT_OID_HEXSZ + 1, git_object_id(git.GetData().object)); } BOOST_LOG_TRIVIAL(trace) << "Getting date for Git object."; const git_oid * oid = git_object_id(git.GetData().object); git.Call(git_commit_lookup(&git.GetData().commit, git.GetData().repo, oid)); git_time_t time = git_commit_time(git.GetData().commit); boost::locale::date_time dateTime(time); std::stringstream out; out << boost::locale::as::ftime("%Y-%m-%d") << dateTime; info.revision_date = out.str(); BOOST_LOG_TRIVIAL(trace) << "Diffing masterlist HEAD and working copy."; info.is_modified = GitHelper::IsFileDifferent(path.parent_path(), path.filename().string()); return info; }
int CGitHeadFileList::ReadTree() { CStringA gitdir = CUnicodeUtils::GetMulti(m_Gitdir,CP_ACP) ; gitdir += "\\.git"; git_repository *repository = NULL; git_commit *commit = NULL; git_tree * tree = NULL; int ret = 0; this->clear(); // hack to avoid duplicates in the head list, which are introduced in GitStatus::GetFileStatus when this method is called do { ret = git_repository_open(&repository, gitdir.GetBuffer()); if(ret) break; ret = git_commit_lookup(&commit, repository, (const git_oid*)m_Head.m_hash); if(ret) break; ret = git_commit_tree(&tree, commit); if(ret) break; ret = ReadTreeRecursive(*repository, tree,"", CGitHeadFileList::CallBack,this); if(ret) break; std::sort(this->begin(), this->end(), SortTree); this->m_TreeHash = (char*)(git_commit_id(commit)->id); } while(0); if (tree) git_tree_free(tree); if (commit) git_commit_free(commit); if (repository) git_repository_free(repository); return ret; }
void test_checkout_tree__removes_conflicts_only_by_pathscope(void) { git_oid commit_id; git_commit *commit; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; git_index *index; const char *path = "executable.txt"; cl_git_pass(git_oid_fromstr(&commit_id, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6")); cl_git_pass(git_commit_lookup(&commit, g_repo, &commit_id)); opts.checkout_strategy = GIT_CHECKOUT_FORCE; opts.paths.count = 1; opts.paths.strings = (char **)&path; cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts)); cl_git_pass(git_repository_index(&index, g_repo)); cl_git_pass(git_index_remove(index, "executable.txt", 0)); create_conflict("executable.txt"); cl_git_mkfile("testrepo/executable.txt", "This is the conflict file.\n"); create_conflict("other.txt"); cl_git_mkfile("testrepo/other.txt", "This is another conflict file.\n"); git_index_write(index); cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts)); cl_assert_equal_p(NULL, git_index_get_bypath(index, "executable.txt", 1)); cl_assert_equal_p(NULL, git_index_get_bypath(index, "executable.txt", 2)); cl_assert_equal_p(NULL, git_index_get_bypath(index, "executable.txt", 3)); cl_assert(git_index_get_bypath(index, "other.txt", 1) != NULL); cl_assert(git_index_get_bypath(index, "other.txt", 2) != NULL); cl_assert(git_index_get_bypath(index, "other.txt", 3) != NULL); cl_assert(git_path_exists("testrepo/other.txt")); git_commit_free(commit); git_index_free(index); }
void test_rebase_inmemory__with_directories(void) { git_rebase *rebase; git_reference *branch_ref, *upstream_ref; git_annotated_commit *branch_head, *upstream_head; git_rebase_operation *rebase_operation; git_oid commit_id, tree_id; git_commit *commit; git_rebase_options opts = GIT_REBASE_OPTIONS_INIT; opts.inmemory = true; git_oid_fromstr(&tree_id, "a4d6d9c3d57308fd8e320cf2525bae8f1adafa57"); cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/deep_gravy")); cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal")); 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)); cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL)); cl_git_pass(git_rebase_next(&rebase_operation, rebase)); cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL)); cl_git_fail_with(GIT_ITEROVER, git_rebase_next(&rebase_operation, rebase)); cl_git_pass(git_commit_lookup(&commit, repo, &commit_id)); cl_assert_equal_oid(&tree_id, git_commit_tree_id(commit)); 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); }
PyObject * Commit_parents__get__(Commit *self) { Repository *py_repo; unsigned int i, parent_count; const git_oid *parent_oid; git_commit *parent; int err; PyObject *py_parent; PyObject *list; parent_count = git_commit_parentcount(self->commit); list = PyList_New(parent_count); if (!list) return NULL; py_repo = self->repo; for (i=0; i < parent_count; i++) { parent_oid = git_commit_parent_id(self->commit, i); if (parent_oid == NULL) { Py_DECREF(list); Error_set(GIT_ENOTFOUND); return NULL; } err = git_commit_lookup(&parent, py_repo->repo, parent_oid); if (err < 0) { Py_DECREF(list); return Error_set_oid(err, parent_oid, GIT_OID_HEXSZ); } py_parent = wrap_object((git_object*)parent, py_repo); if (py_parent == NULL) { Py_DECREF(list); return NULL; } PyList_SET_ITEM(list, i, py_parent); } return list; }
static int rebase_next_inmemory( git_rebase_operation **out, git_rebase *rebase) { git_commit *current_commit = NULL, *parent_commit = NULL; git_tree *current_tree = NULL, *head_tree = NULL, *parent_tree = NULL; git_rebase_operation *operation; git_index *index = NULL; int error; *out = NULL; operation = git_array_get(rebase->operations, rebase->current); if ((error = git_commit_lookup(¤t_commit, rebase->repo, &operation->id)) < 0 || (error = git_commit_tree(¤t_tree, current_commit)) < 0 || (error = git_commit_parent(&parent_commit, current_commit, 0)) < 0 || (error = git_commit_tree(&parent_tree, parent_commit)) < 0 || (error = git_commit_tree(&head_tree, rebase->last_commit)) < 0 || (error = git_merge_trees(&index, rebase->repo, parent_tree, head_tree, current_tree, &rebase->options.merge_options)) < 0) goto done; if (!rebase->index) { rebase->index = index; index = NULL; } else { if ((error = git_index_read_index(rebase->index, index)) < 0) goto done; } *out = operation; done: git_commit_free(current_commit); git_commit_free(parent_commit); git_tree_free(current_tree); git_tree_free(head_tree); git_tree_free(parent_tree); git_index_free(index); return error; }
void test_odb_alternates__long_chain(void) { git_commit *commit; git_oid oid; size_t i; /* Set the alternate A -> testrepo.git */ init_linked_repo(paths[0], cl_fixture("testrepo.git")); /* Set up the five-element chain */ for (i = 1; i < ARRAY_SIZE(paths); i++) { init_linked_repo(paths[i], paths[i-1]); } /* Now load the last one and see if we can find an object from testrepo.git */ cl_git_pass(git_repository_open(&repo, paths[ARRAY_SIZE(paths)-1])); git_oid_fromstr(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"); cl_git_fail(git_commit_lookup(&commit, repo, &oid)); git_repository_free(repo); }
static void test_checkout_fails(const char *refname, const char *filename) { git_oid commit_id; git_commit *commit; git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT; git_buf path = GIT_BUF_INIT; cl_git_pass(git_buf_joinpath(&path, repo_name, filename)); cl_git_pass(git_reference_name_to_id(&commit_id, repo, refname)); cl_git_pass(git_commit_lookup(&commit, repo, &commit_id)); opts.checkout_strategy = GIT_CHECKOUT_FORCE; cl_git_fail(git_checkout_tree(repo, (const git_object *)commit, &opts)); cl_assert(!git_path_exists(path.ptr)); git_commit_free(commit); git_buf_free(&path); }