void CGitPropertyPage::DisplayCommit(const git_commit* commit, UINT hashLabel, UINT subjectLabel, UINT authorLabel, UINT dateLabel)
{
if (commit == NULL)
{
SetDlgItemText(m_hwnd, hashLabel, _T(""));
SetDlgItemText(m_hwnd, subjectLabel, _T(""));
SetDlgItemText(m_hwnd, authorLabel, _T(""));
SetDlgItemText(m_hwnd, dateLabel, _T(""));
return;
}
int encode = CP_UTF8;
const char * encodingString = git_commit_message_encoding(commit);
if (encodingString != NULL)
encode = CUnicodeUtils::GetCPCode(CUnicodeUtils::GetUnicode(encodingString));
const git_signature * author = git_commit_author(commit);
CString authorName = CUnicodeUtils::GetUnicode(author->name, encode);
CString message = CUnicodeUtils::GetUnicode(git_commit_message(commit), encode);
int start = 0;
message = message.Tokenize(L"\n", start);
SetDlgItemText(m_hwnd, hashLabel, CGitHash((char*)(git_commit_id(commit)->id)).ToString());
SetDlgItemText(m_hwnd, subjectLabel, message);
SetDlgItemText(m_hwnd, authorLabel, authorName);
CString authorDate;
Time64ToTimeString(author->when.time, authorDate.GetBufferSetLength(200), 200);
SetDlgItemText(m_hwnd, dateLabel, authorDate);
}
//go through history using the revwalker object
bool MainWindow::walkHistory(git_commit* commit)
{
git_commit* wcommit;
const char* cmsg;
const git_oid* oid = git_commit_id(commit);
git_oid commit_oid;
git_oid_cpy(&commit_oid, oid);
git_revwalk* walker;
git_revwalk_new(&walker, repo);
git_revwalk_sorting(walker, GIT_SORT_TOPOLOGICAL | GIT_SORT_TIME);
git_revwalk_push(walker, &commit_oid);
while (git_revwalk_next(&commit_oid, walker) == 0)
{
int error = git_commit_lookup(&wcommit, repo, &commit_oid);
cmsg = git_commit_message(wcommit);
qDebug() << "Commit msg = " << cmsg;
git_commit_free(wcommit);
}
git_revwalk_free(walker);
}
void MainWindow::lookupCommits()
{
if (repo != NULL)
{
git_oid parent_id;
git_commit* commit;
//get the head commit ID
int error = git_reference_name_to_id(&parent_id, repo, "HEAD");
//get the actual commit object
error = git_commit_lookup(&commit, repo, &parent_id);
qDebug() << "Head commit = " << git_commit_message(commit);
unsigned int count = git_commit_parentcount(commit);
qDebug() << "numParents = " << count;
commitIDs.clear();
lookupDone = false;
walkHistory(commit);
}
}
const char *git_commit_summary(git_commit *commit)
{
git_buf summary = GIT_BUF_INIT;
const char *msg, *space;
assert(commit);
if (!commit->summary) {
for (msg = git_commit_message(commit), space = NULL; *msg; ++msg) {
if (msg[0] == '\n' && (!msg[1] || msg[1] == '\n'))
break;
else if (msg[0] == '\n')
git_buf_putc(&summary, ' ');
else if (git__isspace(msg[0]))
space = space ? space : msg;
else if (space) {
git_buf_put(&summary, space, (msg - space) + 1);
space = NULL;
} else
git_buf_putc(&summary, *msg);
}
commit->summary = git_buf_detach(&summary);
if (!commit->summary)
commit->summary = git__strdup("");
}
return commit->summary;
}
/** 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");
}
/**
* Init slots in S4 class git_commit
*
* @param source a commit object
* @param repo S4 class git_repository that contains the blob
* @param dest S4 class git_commit to initialize
* @return void
*/
void git2r_commit_init(git_commit *source, SEXP repo, SEXP dest)
{
const char *message;
const char *summary;
const git_signature *author;
const git_signature *committer;
char sha[GIT_OID_HEXSZ + 1];
git_oid_fmt(sha, git_commit_id(source));
sha[GIT_OID_HEXSZ] = '\0';
SET_SLOT(dest, Rf_install("sha"), mkString(sha));
author = git_commit_author(source);
if (author)
git2r_signature_init(author, GET_SLOT(dest, Rf_install("author")));
committer = git_commit_committer(source);
if (committer)
git2r_signature_init(committer, GET_SLOT(dest, Rf_install("committer")));
summary = git_commit_summary(source);
if (summary)
SET_SLOT(dest, Rf_install("summary"), mkString(summary));
message = git_commit_message(source);
if (message)
SET_SLOT(dest, Rf_install("message"), mkString(message));
SET_SLOT(dest, Rf_install("repo"), repo);
}
const char *git_commit_body(git_commit *commit)
{
const char *msg, *end;
assert(commit);
if (!commit->body) {
/* search for end of summary */
for (msg = git_commit_message(commit); *msg; ++msg)
if (msg[0] == '\n' && (!msg[1] || msg[1] == '\n'))
break;
/* trim leading and trailing whitespace */
for (; *msg; ++msg)
if (!git__isspace(*msg))
break;
for (end = msg + strlen(msg) - 1; msg <= end; --end)
if (!git__isspace(*end))
break;
if (*msg)
commit->body = git__strndup(msg, end - msg + 1);
}
return commit->body;
}
static VALUE rb_git_commit_message_GET(VALUE self)
{
git_commit *commit;
Data_Get_Struct(self, git_commit, commit);
return rb_str_new2(git_commit_message(commit));
}
static int walk_and_search(git_object **out, git_revwalk *walk, regex_t *regex)
{
int error;
git_oid oid;
git_object *obj;
while (!(error = git_revwalk_next(&oid, walk))) {
error = git_object_lookup(&obj, git_revwalk_repository(walk), &oid, GIT_OBJ_COMMIT);
if ((error < 0) && (error != GIT_ENOTFOUND))
return -1;
if (!regexec(regex, git_commit_message((git_commit*)obj), 0, NULL, 0)) {
*out = obj;
return 0;
}
git_object_free(obj);
}
if (error < 0 && error == GIT_ITEROVER)
error = GIT_ENOTFOUND;
return error;
}
static VALUE rb_git_commit_message_GET(VALUE self)
{
git_commit *commit;
RUGGED_OBJ_UNWRAP(self, git_commit, commit);
return rugged_str_new2(git_commit_message(commit), NULL);
}
QString Commit::shortLog()
{
QRegExp regex("(\\r|\\n)");
QString log = QString(git_commit_message(commit));
QString shortLog = log.left(80).split(regex).first();
return shortLog;
}
QString Commit::log() const
{
QRegExp regex("(\\r|\\n)");
QString log = QString(git_commit_message(commit));
log = log.remove(0, log.indexOf(regex) + 1);
return log;
}
int git_cherrypick(
git_repository *repo,
git_commit *commit,
const git_cherrypick_options *given_opts)
{
git_cherrypick_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 = NULL;
git_indexwriter indexwriter = GIT_INDEXWRITER_INIT;
int error = 0;
assert(repo && commit);
GITERR_CHECK_VERSION(given_opts, GIT_CHERRYPICK_OPTIONS_VERSION, "git_cherrypick_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 = cherrypick_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_cherrypick_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_cherrypick_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:
cherrypick_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;
}
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);
}
PyObject *
Commit_message__get__(Commit *commit)
{
const char *message, *encoding;
message = git_commit_message(commit->commit);
encoding = git_commit_message_encoding(commit->commit);
return to_unicode(message, encoding, "strict");
}
// query the details on a parsed commit
void test_commit_parse__details0(void) {
static const char *commit_ids[] = {
"a4a7dce85cf63874e984719f4fdd239f5145052f", /* 0 */
"9fd738e8f7967c078dceed8190330fc8648ee56a", /* 1 */
"4a202b346bb0fb0db7eff3cffeb3c70babbd2045", /* 2 */
"c47800c7266a2be04c571c04d5a6614691ea99bd", /* 3 */
"8496071c1b46c854b31185ea97743be6a8774479", /* 4 */
"5b5b025afb0b4c913b4c338a42934a3863bf3644", /* 5 */
"a65fedf39aefe402d3bb6e24df4d4f5fe4547750", /* 6 */
};
const size_t commit_count = sizeof(commit_ids) / sizeof(const char *);
unsigned int i;
for (i = 0; i < commit_count; ++i) {
git_oid id;
git_commit *commit;
const git_signature *author, *committer;
const char *message;
git_time_t commit_time;
unsigned int parents, p;
git_commit *parent = NULL, *old_parent = NULL;
git_oid_fromstr(&id, commit_ids[i]);
cl_git_pass(git_commit_lookup(&commit, g_repo, &id));
message = git_commit_message(commit);
author = git_commit_author(commit);
committer = git_commit_committer(commit);
commit_time = git_commit_time(commit);
parents = git_commit_parentcount(commit);
cl_assert_equal_s("Scott Chacon", author->name);
cl_assert_equal_s("*****@*****.**", author->email);
cl_assert_equal_s("Scott Chacon", committer->name);
cl_assert_equal_s("*****@*****.**", committer->email);
cl_assert(message != NULL);
cl_assert(strchr(message, '\n') != NULL);
cl_assert(commit_time > 0);
cl_assert(parents <= 2);
for (p = 0;p < parents;p++) {
if (old_parent != NULL)
git_commit_free(old_parent);
old_parent = parent;
cl_git_pass(git_commit_parent(&parent, commit, p));
cl_assert(parent != NULL);
cl_assert(git_commit_author(parent) != NULL); // is it really a commit?
}
git_commit_free(old_parent);
git_commit_free(parent);
cl_git_fail(git_commit_parent(&parent, commit, parents));
git_commit_free(commit);
}
}
static void assert_commit_message_contains(const char *revision, const char *fragment)
{
git_commit *commit;
cl_git_pass(git_revparse_single(((git_object **)&commit), repo, revision));
cl_assert(strstr(git_commit_message(commit), fragment) != NULL);
git_commit_free(commit);
}
// write a new commit object from memory to disk
void test_commit_write__from_memory(void)
{
git_oid tree_id, parent_id, commit_id;
git_signature *author, *committer;
const git_signature *author1, *committer1;
git_commit *parent;
git_tree *tree;
const char *commit_id_str = "8496071c1b46c854b31185ea97743be6a8774479";
git_oid_fromstr(&tree_id, tree_oid);
cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
git_oid_fromstr(&parent_id, commit_id_str);
cl_git_pass(git_commit_lookup(&parent, g_repo, &parent_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));
cl_git_pass(git_commit_create_v(
&commit_id, /* out id */
g_repo,
NULL, /* do not update the HEAD */
author,
committer,
NULL,
commit_message,
tree,
1, parent));
git_object_free((git_object *)parent);
git_object_free((git_object *)tree);
git_signature_free(committer);
git_signature_free(author);
cl_git_pass(git_commit_lookup(&commit, g_repo, &commit_id));
/* Check attributes were set correctly */
author1 = git_commit_author(commit);
cl_assert(author1 != NULL);
cl_assert_equal_s(committer_name, author1->name);
cl_assert_equal_s(committer_email, author1->email);
cl_assert(author1->when.time == 987654321);
cl_assert(author1->when.offset == 90);
committer1 = git_commit_committer(commit);
cl_assert(committer1 != NULL);
cl_assert_equal_s(committer_name, committer1->name);
cl_assert_equal_s(committer_email, committer1->email);
cl_assert(committer1->when.time == 123456789);
cl_assert(committer1->when.offset == 60);
cl_assert_equal_s(commit_message, git_commit_message(commit));
}
/**
* 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));
}
void test_commit_parse__entire_commit(void)
{
const int broken_commit_count = sizeof(failing_commit_cases) / sizeof(*failing_commit_cases);
const int working_commit_count = sizeof(passing_commit_cases) / sizeof(*passing_commit_cases);
int i;
for (i = 0; i < broken_commit_count; ++i) {
git_commit *commit;
commit = (git_commit*)git__malloc(sizeof(git_commit));
memset(commit, 0x0, sizeof(git_commit));
commit->object.repo = g_repo;
cl_git_fail(git_commit__parse_buffer(
commit, failing_commit_cases[i], strlen(failing_commit_cases[i]))
);
git_commit__free(commit);
}
for (i = 0; i < working_commit_count; ++i) {
git_commit *commit;
commit = (git_commit*)git__malloc(sizeof(git_commit));
memset(commit, 0x0, sizeof(git_commit));
commit->object.repo = g_repo;
cl_git_pass(git_commit__parse_buffer(
commit,
passing_commit_cases[i],
strlen(passing_commit_cases[i]))
);
if (!i)
cl_assert_equal_s("\n", git_commit_message(commit));
else
cl_assert(git__prefixcmp(
git_commit_message(commit), "a simple commit which works") == 0);
git_commit__free(commit);
}
}
CString CGitRefCompareList::GetCommitMessage(git_commit *commit)
{
int encode = CP_UTF8;
const char *encodingString = git_commit_message_encoding(commit);
if (encodingString != nullptr)
encode = CUnicodeUtils::GetCPCode(CUnicodeUtils::GetUnicode(encodingString));
CString message = CUnicodeUtils::GetUnicode(git_commit_message(commit), encode);
int start = 0;
message = message.Tokenize(_T("\n"), start);
return message;
}
/** Tag listing: Print a commit (target of a lightweight tag) */
static void print_commit(git_commit *commit, const char *name,
const tag_state *state)
{
printf("%-16s", name);
if (state->opts->num_lines) {
const char *msg = git_commit_message(commit);
print_list_lines(msg, state);
} else {
printf("\n");
}
}
// 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);
git_reference_free(head);
cl_git_pass(git_reference_symbolic_create(&head, g_repo, "HEAD", branch_name, 1));
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));
}
/*
* call-seq:
* commit.message -> msg
*
* Return the message of this commit. This includes the full body of the
* message, with the short description, detailed descritpion, and any
* optional footers or signatures after it.
*
* In Ruby 1.9+, the returned string will be encoded with the encoding
* specified in the +Encoding+ header of the commit, if available.
*
* commit.message #=> "add a lot of RDoc docs\n\nthis includes docs for commit and blob"
*/
static VALUE rb_git_commit_message_GET(VALUE self)
{
git_commit *commit;
rb_encoding *encoding = rb_utf8_encoding();
const char *encoding_name;
const char *message;
Data_Get_Struct(self, git_commit, commit);
message = git_commit_message(commit);
encoding_name = git_commit_message_encoding(commit);
if (encoding_name != NULL)
encoding = rb_enc_find(encoding_name);
return rb_enc_str_new(message, strlen(message), encoding);
}
const char *git_commit_summary(git_commit *commit)
{
git_buf summary = GIT_BUF_INIT;
const char *msg, *space;
bool space_contains_newline = false;
assert(commit);
if (!commit->summary) {
for (msg = git_commit_message(commit), space = NULL; *msg; ++msg) {
char next_character = msg[0];
/* stop processing at the end of the first paragraph */
if (next_character == '\n' && (!msg[1] || msg[1] == '\n'))
break;
/* record the beginning of contiguous whitespace runs */
else if (git__isspace(next_character)) {
if(space == NULL) {
space = msg;
space_contains_newline = false;
}
space_contains_newline |= next_character == '\n';
}
/* the next character is non-space */
else {
/* process any recorded whitespace */
if (space) {
if(space_contains_newline)
git_buf_putc(&summary, ' '); /* if the space contains a newline, collapse to ' ' */
else
git_buf_put(&summary, space, (msg - space)); /* otherwise copy it */
space = NULL;
}
/* copy the next character */
git_buf_putc(&summary, next_character);
}
}
commit->summary = git_buf_detach(&summary);
if (!commit->summary)
commit->summary = git__strdup("");
}
return commit->summary;
}
static int append_commit_description(git_buf *out, git_commit* commit)
{
const char *message;
size_t pos = 0, len;
if (append_abbreviated_oid(out, git_commit_id(commit)) < 0)
return -1;
message = git_commit_message(commit);
len = strlen(message);
/* TODO: Replace with proper commit short message
* when git_commit_message_short() is implemented.
*/
while (pos < len && message[pos] != '\n')
pos++;
git_buf_putc(out, ' ');
git_buf_put(out, message, pos);
git_buf_putc(out, '\n');
return git_buf_oom(out) ? -1 : 0;
}
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_internal(
id, repo, NULL, author, committer, message_encoding, message,
&tree_id, commit_parent_for_amend, (void *)commit_to_amend, false);
if (!error && update_ref) {
error = git_reference__update_for_commit(
repo, ref, NULL, id, "commit");
git_reference_free(ref);
}
return error;
}
int main (int argc, char** argv)
{
// ### Opening the Repository
// There are a couple of methods for opening a repository, this being the simplest.
// There are also [methods][me] for specifying the index file and work tree locations, here
// we are assuming they are in the normal places.
//
// [me]: http://libgit2.github.com/libgit2/#HEAD/group/repository
git_repository *repo;
if (argc > 1) {
git_repository_open(&repo, argv[1]);
} else {
git_repository_open(&repo, "/opt/libgit2-test/.git");
}
// ### SHA-1 Value Conversions
// For our first example, we will convert a 40 character hex value to the 20 byte raw SHA1 value.
printf("*Hex to Raw*\n");
char hex[] = "fd6e612585290339ea8bf39c692a7ff6a29cb7c3";
// The `git_oid` is the structure that keeps the SHA value. We will use this throughout the example
// for storing the value of the current SHA key we're working with.
git_oid oid;
git_oid_fromstr(&oid, hex);
// Once we've converted the string into the oid value, we can get the raw value of the SHA.
printf("Raw 20 bytes: [%.20s]\n", (&oid)->id);
// Next we will convert the 20 byte raw SHA1 value to a human readable 40 char hex value.
printf("\n*Raw to Hex*\n");
char out[41];
out[40] = '\0';
// If you have a oid, you can easily get the hex value of the SHA as well.
git_oid_fmt(out, &oid);
printf("SHA hex string: %s\n", out);
// ### Working with the Object Database
// **libgit2** provides [direct access][odb] to the object database.
// The object database is where the actual objects are stored in Git. For
// working with raw objects, we'll need to get this structure from the
// repository.
// [odb]: http://libgit2.github.com/libgit2/#HEAD/group/odb
git_odb *odb;
git_repository_odb(&odb, repo);
// #### Raw Object Reading
printf("\n*Raw Object Read*\n");
git_odb_object *obj;
git_otype otype;
const unsigned char *data;
const char *str_type;
int error;
// We can read raw objects directly from the object database if we have the oid (SHA)
// of the object. This allows us to access objects without knowing thier type and inspect
// the raw bytes unparsed.
error = git_odb_read(&obj, odb, &oid);
// A raw object only has three properties - the type (commit, blob, tree or tag), the size
// of the raw data and the raw, unparsed data itself. For a commit or tag, that raw data
// is human readable plain ASCII text. For a blob it is just file contents, so it could be
// text or binary data. For a tree it is a special binary format, so it's unlikely to be
// hugely helpful as a raw object.
data = (const unsigned char *)git_odb_object_data(obj);
otype = git_odb_object_type(obj);
// We provide methods to convert from the object type which is an enum, to a string
// representation of that value (and vice-versa).
str_type = git_object_type2string(otype);
printf("object length and type: %d, %s\n",
(int)git_odb_object_size(obj),
str_type);
// For proper memory management, close the object when you are done with it or it will leak
// memory.
git_odb_object_free(obj);
// #### Raw Object Writing
printf("\n*Raw Object Write*\n");
// You can also write raw object data to Git. This is pretty cool because it gives you
// direct access to the key/value properties of Git. Here we'll write a new blob object
// that just contains a simple string. Notice that we have to specify the object type as
// the `git_otype` enum.
git_odb_write(&oid, odb, "test data", sizeof("test data") - 1, GIT_OBJ_BLOB);
// Now that we've written the object, we can check out what SHA1 was generated when the
// object was written to our database.
git_oid_fmt(out, &oid);
printf("Written Object: %s\n", out);
// ### Object Parsing
// libgit2 has methods to parse every object type in Git so you don't have to work directly
// with the raw data. This is much faster and simpler than trying to deal with the raw data
// yourself.
// #### Commit Parsing
// [Parsing commit objects][pco] is simple and gives you access to all the data in the commit
// - the // author (name, email, datetime), committer (same), tree, message, encoding and parent(s).
// [pco]: http://libgit2.github.com/libgit2/#HEAD/group/commit
printf("\n*Commit Parsing*\n");
git_commit *commit;
git_oid_fromstr(&oid, "f0877d0b841d75172ec404fc9370173dfffc20d1");
error = git_commit_lookup(&commit, repo, &oid);
const git_signature *author, *cmtter;
const char *message;
time_t ctime;
unsigned int parents, p;
// Each of the properties of the commit object are accessible via methods, including commonly
// needed variations, such as `git_commit_time` which returns the author time and `_message`
// which gives you the commit message.
message = git_commit_message(commit);
author = git_commit_author(commit);
cmtter = git_commit_committer(commit);
ctime = git_commit_time(commit);
// The author and committer methods return [git_signature] structures, which give you name, email
// and `when`, which is a `git_time` structure, giving you a timestamp and timezone offset.
printf("Author: %s (%s)\n", author->name, author->email);
// Commits can have zero or more parents. The first (root) commit will have no parents, most commits
// will have one, which is the commit it was based on, and merge commits will have two or more.
// Commits can technically have any number, though it's pretty rare to have more than two.
parents = git_commit_parentcount(commit);
for (p = 0;p < parents;p++) {
git_commit *parent;
git_commit_parent(&parent, commit, p);
git_oid_fmt(out, git_commit_id(parent));
printf("Parent: %s\n", out);
git_commit_free(parent);
}
// Don't forget to close the object to prevent memory leaks. You will have to do this for
// all the objects you open and parse.
git_commit_free(commit);
// #### Writing Commits
//
// libgit2 provides a couple of methods to create commit objects easily as well. There are four
// different create signatures, we'll just show one of them here. You can read about the other
// ones in the [commit API docs][cd].
// [cd]: http://libgit2.github.com/libgit2/#HEAD/group/commit
printf("\n*Commit Writing*\n");
git_oid tree_id, parent_id, commit_id;
git_tree *tree;
git_commit *parent;
// Creating signatures for an authoring identity and time is pretty simple - you will need to have
// this to create a commit in order to specify who created it and when. Default values for the name
// and email should be found in the `user.name` and `user.email` configuration options. See the `config`
// section of this example file to see how to access config values.
git_signature_new((git_signature **)&author, "Scott Chacon", "*****@*****.**",
123456789, 60);
git_signature_new((git_signature **)&cmtter, "Scott A Chacon", "*****@*****.**",
987654321, 90);
// Commit objects need a tree to point to and optionally one or more parents. Here we're creating oid
// objects to create the commit with, but you can also use
git_oid_fromstr(&tree_id, "28873d96b4e8f4e33ea30f4c682fd325f7ba56ac");
git_tree_lookup(&tree, repo, &tree_id);
git_oid_fromstr(&parent_id, "f0877d0b841d75172ec404fc9370173dfffc20d1");
git_commit_lookup(&parent, repo, &parent_id);
// Here we actually create the commit object with a single call with all the values we need to create
// the commit. The SHA key is written to the `commit_id` variable here.
git_commit_create_v(
&commit_id, /* out id */
repo,
NULL, /* do not update the HEAD */
author,
cmtter,
NULL, /* use default message encoding */
"example commit",
tree,
1, parent);
// Now we can take a look at the commit SHA we've generated.
git_oid_fmt(out, &commit_id);
printf("New Commit: %s\n", out);
// #### Tag Parsing
// You can parse and create tags with the [tag management API][tm], which functions very similarly
// to the commit lookup, parsing and creation methods, since the objects themselves are very similar.
// [tm]: http://libgit2.github.com/libgit2/#HEAD/group/tag
printf("\n*Tag Parsing*\n");
git_tag *tag;
const char *tmessage, *tname;
git_otype ttype;
// We create an oid for the tag object if we know the SHA and look it up in the repository the same
// way that we would a commit (or any other) object.
git_oid_fromstr(&oid, "bc422d45275aca289c51d79830b45cecebff7c3a");
error = git_tag_lookup(&tag, repo, &oid);
// Now that we have the tag object, we can extract the information it generally contains: the target
// (usually a commit object), the type of the target object (usually 'commit'), the name ('v1.0'),
// the tagger (a git_signature - name, email, timestamp), and the tag message.
git_tag_target((git_object **)&commit, tag);
tname = git_tag_name(tag); // "test"
ttype = git_tag_type(tag); // GIT_OBJ_COMMIT (otype enum)
tmessage = git_tag_message(tag); // "tag message\n"
printf("Tag Message: %s\n", tmessage);
git_commit_free(commit);
// #### Tree Parsing
// [Tree parsing][tp] is a bit different than the other objects, in that we have a subtype which is the
// tree entry. This is not an actual object type in Git, but a useful structure for parsing and
// traversing tree entries.
//
// [tp]: http://libgit2.github.com/libgit2/#HEAD/group/tree
printf("\n*Tree Parsing*\n");
const git_tree_entry *entry;
git_object *objt;
// Create the oid and lookup the tree object just like the other objects.
git_oid_fromstr(&oid, "2a741c18ac5ff082a7caaec6e74db3075a1906b5");
git_tree_lookup(&tree, repo, &oid);
// Getting the count of entries in the tree so you can iterate over them if you want to.
int cnt = git_tree_entrycount(tree); // 3
printf("tree entries: %d\n", cnt);
entry = git_tree_entry_byindex(tree, 0);
printf("Entry name: %s\n", git_tree_entry_name(entry)); // "hello.c"
// You can also access tree entries by name if you know the name of the entry you're looking for.
entry = git_tree_entry_byname(tree, "hello.c");
git_tree_entry_name(entry); // "hello.c"
// Once you have the entry object, you can access the content or subtree (or commit, in the case
// of submodules) that it points to. You can also get the mode if you want.
git_tree_entry_to_object(&objt, repo, entry); // blob
// Remember to close the looked-up object once you are done using it
git_object_free(objt);
// #### Blob Parsing
//
// The last object type is the simplest and requires the least parsing help. Blobs are just file
// contents and can contain anything, there is no structure to it. The main advantage to using the
// [simple blob api][ba] is that when you're creating blobs you don't have to calculate the size
// of the content. There is also a helper for reading a file from disk and writing it to the db and
// getting the oid back so you don't have to do all those steps yourself.
//
// [ba]: http://libgit2.github.com/libgit2/#HEAD/group/blob
printf("\n*Blob Parsing*\n");
git_blob *blob;
git_oid_fromstr(&oid, "af7574ea73f7b166f869ef1a39be126d9a186ae0");
git_blob_lookup(&blob, repo, &oid);
// You can access a buffer with the raw contents of the blob directly.
// Note that this buffer may not be contain ASCII data for certain blobs (e.g. binary files):
// do not consider the buffer a NULL-terminated string, and use the `git_blob_rawsize` attribute to
// find out its exact size in bytes
printf("Blob Size: %ld\n", git_blob_rawsize(blob)); // 8
git_blob_rawcontent(blob); // "content"
// ### Revwalking
//
// The libgit2 [revision walking api][rw] provides methods to traverse the directed graph created
// by the parent pointers of the commit objects. Since all commits point back to the commit that
// came directly before them, you can walk this parentage as a graph and find all the commits that
// were ancestors of (reachable from) a given starting point. This can allow you to create `git log`
// type functionality.
//
// [rw]: http://libgit2.github.com/libgit2/#HEAD/group/revwalk
printf("\n*Revwalking*\n");
git_revwalk *walk;
git_commit *wcommit;
git_oid_fromstr(&oid, "f0877d0b841d75172ec404fc9370173dfffc20d1");
// To use the revwalker, create a new walker, tell it how you want to sort the output and then push
// one or more starting points onto the walker. If you want to emulate the output of `git log` you
// would push the SHA of the commit that HEAD points to into the walker and then start traversing them.
// You can also 'hide' commits that you want to stop at or not see any of their ancestors. So if you
// want to emulate `git log branch1..branch2`, you would push the oid of `branch2` and hide the oid
// of `branch1`.
git_revwalk_new(&walk, repo);
git_revwalk_sorting(walk, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE);
git_revwalk_push(walk, &oid);
const git_signature *cauth;
const char *cmsg;
// Now that we have the starting point pushed onto the walker, we can start asking for ancestors. It
// will return them in the sorting order we asked for as commit oids.
// We can then lookup and parse the commited pointed at by the returned OID;
// note that this operation is specially fast since the raw contents of the commit object will
// be cached in memory
while ((git_revwalk_next(&oid, walk)) == 0) {
error = git_commit_lookup(&wcommit, repo, &oid);
cmsg = git_commit_message(wcommit);
cauth = git_commit_author(wcommit);
printf("%s (%s)\n", cmsg, cauth->email);
git_commit_free(wcommit);
}
// Like the other objects, be sure to free the revwalker when you're done to prevent memory leaks.
// Also, make sure that the repository being walked it not deallocated while the walk is in
// progress, or it will result in undefined behavior
git_revwalk_free(walk);
// ### Index File Manipulation
//
// The [index file API][gi] allows you to read, traverse, update and write the Git index file
// (sometimes thought of as the staging area).
//
// [gi]: http://libgit2.github.com/libgit2/#HEAD/group/index
printf("\n*Index Walking*\n");
git_index *index;
unsigned int i, ecount;
// You can either open the index from the standard location in an open repository, as we're doing
// here, or you can open and manipulate any index file with `git_index_open_bare()`. The index
// for the repository will be located and loaded from disk.
git_repository_index(&index, repo);
// For each entry in the index, you can get a bunch of information including the SHA (oid), path
// and mode which map to the tree objects that are written out. It also has filesystem properties
// to help determine what to inspect for changes (ctime, mtime, dev, ino, uid, gid, file_size and flags)
// All these properties are exported publicly in the `git_index_entry` struct
ecount = git_index_entrycount(index);
for (i = 0; i < ecount; ++i) {
git_index_entry *e = git_index_get(index, i);
printf("path: %s\n", e->path);
printf("mtime: %d\n", (int)e->mtime.seconds);
printf("fs: %d\n", (int)e->file_size);
}
git_index_free(index);
// ### References
//
// The [reference API][ref] allows you to list, resolve, create and update references such as
// branches, tags and remote references (everything in the .git/refs directory).
//
// [ref]: http://libgit2.github.com/libgit2/#HEAD/group/reference
printf("\n*Reference Listing*\n");
// Here we will implement something like `git for-each-ref` simply listing out all available
// references and the object SHA they resolve to.
git_strarray ref_list;
git_reference_list(&ref_list, repo, GIT_REF_LISTALL);
const char *refname;
git_reference *ref;
// Now that we have the list of reference names, we can lookup each ref one at a time and
// resolve them to the SHA, then print both values out.
for (i = 0; i < ref_list.count; ++i) {
refname = ref_list.strings[i];
git_reference_lookup(&ref, repo, refname);
switch (git_reference_type(ref)) {
case GIT_REF_OID:
git_oid_fmt(out, git_reference_oid(ref));
printf("%s [%s]\n", refname, out);
break;
case GIT_REF_SYMBOLIC:
printf("%s => %s\n", refname, git_reference_target(ref));
break;
default:
fprintf(stderr, "Unexpected reference type\n");
exit(1);
}
}
git_strarray_free(&ref_list);
// ### Config Files
//
// The [config API][config] allows you to list and updatee config values in
// any of the accessible config file locations (system, global, local).
//
// [config]: http://libgit2.github.com/libgit2/#HEAD/group/config
printf("\n*Config Listing*\n");
const char *email;
int32_t j;
git_config *cfg;
// Open a config object so we can read global values from it.
git_config_open_ondisk(&cfg, "~/.gitconfig");
git_config_get_int32(cfg, "help.autocorrect", &j);
printf("Autocorrect: %d\n", j);
git_config_get_string(cfg, "user.email", &email);
printf("Email: %s\n", email);
// Finally, when you're done with the repository, you can free it as well.
git_repository_free(repo);
return 0;
}
QString QGitCommit::message() const
{
return QString::fromUtf8(git_commit_message(data()));
}
std::string Commit::message() const {
return std::string(git_commit_message(get()));
}
