Rcpp::Reference Commit::parent_id(unsigned int n)
{
BEGIN_RCPP
const git_oid *result = git_commit_parent_id(commit.get(), n);
return OID::create(result);
END_RCPP
}
/** Helper to print a commit object. */
static void print_commit(git_commit *commit)
{
char buf[GIT_OID_HEXSZ + 1];
int i, count;
const git_signature *sig;
const char *scan, *eol;
git_oid_tostr(buf, sizeof(buf), git_commit_id(commit));
printf("commit %s\n", buf);
if ((count = (int)git_commit_parentcount(commit)) > 1) {
printf("Merge:");
for (i = 0; i < count; ++i) {
git_oid_tostr(buf, 8, git_commit_parent_id(commit, i));
printf(" %s", buf);
}
printf("\n");
}
if ((sig = git_commit_author(commit)) != NULL) {
printf("Author: %s <%s>\n", sig->name, sig->email);
print_time(&sig->when, "Date: ");
}
printf("\n");
for (scan = git_commit_message(commit); scan && *scan; ) {
for (eol = scan; *eol && *eol != '\n'; ++eol) /* find eol */;
printf(" %.*s\n", (int)(eol - scan), scan);
scan = *eol ? eol + 1 : NULL;
}
printf("\n");
}
PyObject *
Commit_get_parents(Commit *commit)
{
unsigned int i, parent_count;
const git_oid *parent_oid;
PyObject *obj;
PyObject *list;
parent_count = git_commit_parentcount(commit->commit);
list = PyList_New(parent_count);
if (!list)
return NULL;
for (i=0; i < parent_count; i++) {
parent_oid = git_commit_parent_id(commit->commit, i);
if (parent_oid == NULL) {
Py_DECREF(list);
Error_set(GIT_ENOTFOUND);
return NULL;
}
obj = lookup_object(commit->repo, parent_oid, GIT_OBJ_COMMIT);
if (obj == NULL) {
Py_DECREF(list);
return NULL;
}
PyList_SET_ITEM(list, i, obj);
}
return list;
}
void Commit::populateParentSha()
{
for(int parent = 0; parent < parentCount(); parent++)
{
const git_oid *parentSha = git_commit_parent_id(commit, parent);
parentShas.insert(parent, new Sha(parentSha));
}
}
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_oid commit_id, tree_id, parent_id;
git_signature *author;
git_commit *commit;
git_reflog *reflog;
const git_reflog_entry *reflog_entry;
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, 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_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 GitRev::ParserParentFromCommit(const git_commit* commit)
{
m_ParentHash.clear();
unsigned int parentCount = git_commit_parentcount(commit);
for (unsigned int i = 0; i < parentCount; ++i)
m_ParentHash.emplace_back(git_commit_parent_id(commit, i)->id);
return 0;
}
int luagi_commit_parent_id( lua_State *L )
{
git_commit** commit = checkcommit( L );
unsigned int n = luaL_checkinteger( L, 2 );
//luas index starts with 1
n--;
const git_oid* oid = git_commit_parent_id( *commit, n );
return luagi_push_oid( L, oid );
}
int git_commit_parent(git_commit **parent, 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);
}
PyObject *
Commit_parent_ids__get__(Commit *self)
{
unsigned int i, parent_count;
const git_oid *id;
PyObject *list;
parent_count = git_commit_parentcount(self->commit);
list = PyList_New(parent_count);
if (!list)
return NULL;
for (i=0; i < parent_count; i++) {
id = git_commit_parent_id(self->commit, i);
PyList_SET_ITEM(list, i, git_oid_to_python(id));
}
return list;
}
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;
}
/**
* Commits and tags have a few interesting fields in their header.
*/
static void show_commit(const git_commit *commit)
{
unsigned int i, max_i;
char oidstr[GIT_OID_HEXSZ + 1];
git_oid_tostr(oidstr, sizeof(oidstr), git_commit_tree_id(commit));
printf("tree %s\n", oidstr);
max_i = (unsigned int)git_commit_parentcount(commit);
for (i = 0; i < max_i; ++i) {
git_oid_tostr(oidstr, sizeof(oidstr), git_commit_parent_id(commit, i));
printf("parent %s\n", oidstr);
}
print_signature("author", git_commit_author(commit));
print_signature("committer", git_commit_committer(commit));
if (git_commit_message(commit))
printf("\n%s\n", git_commit_message(commit));
}
/*
* call-seq:
* commit.parent_ids -> [oid, ...]
*
* Return the parent oid(s) of this commit as an array of oid String
* objects. An array is always returned even when the commit has only
* one or zero parents.
*
* commit.parent_ids #=> => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1", ...]
* root.parent_ids #=> []
*/
static VALUE rb_git_commit_parent_ids_GET(VALUE self)
{
git_commit *commit;
const git_oid *parent_id;
unsigned int n, parent_count;
VALUE ret_arr;
Data_Get_Struct(self, git_commit, commit);
parent_count = git_commit_parentcount(commit);
ret_arr = rb_ary_new2((long)parent_count);
for (n = 0; n < parent_count; n++) {
parent_id = git_commit_parent_id(commit, n);
if (parent_id) {
rb_ary_push(ret_arr, rugged_create_oid(parent_id));
}
}
return ret_arr;
}
QGitOId QGitCommit::parentId(unsigned n) const
{
git_oid *parentId;
git_commit_parent_id(data(), n);
return QGitOId(parentId);
}
OId Commit::parentId(unsigned n) const
{
return OId(git_commit_parent_id(data(), n));
}
static git_commit* FindFileRecentCommit(git_repository* repository, const CString& path)
{
CAutoRevwalk walk;
if (git_revwalk_new(walk.GetPointer(), repository))
return nullptr;
CStringA pathA = CUnicodeUtils::GetUTF8(path);
if (pathA.GetLength() >= MAX_PATH)
return nullptr;
const char *pathC = pathA;
char folder[MAX_PATH] = {0}, file[MAX_PATH] = {0};
const char *slash = strrchr(pathC, '/');
if (slash)
{
strncpy(folder, pathC, slash - pathC + 1);
folder[slash - pathC + 1] = '\0';
strcpy(file, slash + 1);
}
else
{
folder[0] = '\0';
strcpy(file, pathC);
}
TreewalkStruct treewalkstruct = { folder, file };
if (git_revwalk_push_head(walk))
return nullptr;
git_oid oid;
CAutoCommit commit;
while (!git_revwalk_next(&oid, walk))
{
if (git_commit_lookup(commit.GetPointer(), repository, &oid))
return nullptr;
CAutoTree tree;
if (git_commit_tree(tree.GetPointer(), commit))
return nullptr;
memset(&treewalkstruct.oid.id, 0, sizeof(treewalkstruct.oid.id));
int ret = git_tree_walk(tree, GIT_TREEWALK_PRE, TreewalkCB_FindFileRecentCommit, &treewalkstruct);
if (ret < 0 && ret != GIT_EUSER)
return nullptr;
// check if file not found
if (git_oid_iszero(&treewalkstruct.oid))
return nullptr;
bool diff = true;
// for merge point, check if it is different to all parents, if yes then there are real change in the merge point.
// if no parent then of course it is different
for (unsigned int i = 0; i < git_commit_parentcount(commit); ++i)
{
CAutoCommit commit2;
if (git_commit_parent(commit2.GetPointer(), commit, i))
return nullptr;
CAutoTree tree2;
if (git_commit_tree(tree2.GetPointer(), commit2))
return nullptr;
TreewalkStruct treewalkstruct2 = { folder, file };
memset(&treewalkstruct2.oid.id, 0, sizeof(treewalkstruct2.oid.id));
int ret = git_tree_walk(tree2, GIT_TREEWALK_PRE, TreewalkCB_FindFileRecentCommit, &treewalkstruct2);
if (ret < 0 && ret != GIT_EUSER)
return nullptr;
if (!git_oid_cmp(&treewalkstruct.oid, &treewalkstruct2.oid))
diff = false;
else if (git_revwalk_hide(walk, git_commit_parent_id(commit, i)))
return nullptr;
}
if (diff)
break;
}
return commit.Detach();
}
