gout

commit.c (4065B)

---

 #include "git/commit.h"
 
 #include <assert.h>
 #include <err.h>
 #include <git2/commit.h>
 #include <git2/diff.h>
 #include <git2/oid.h>
 #include <git2/patch.h>
 #include <git2/tree.h>
 #include <git2/types.h>
 #include <stdlib.h>
 
 #include "git/internal.h"
 
 GitCommit* gitcommit_create(const git_oid* oid, git_repository* repo) {
   assert(oid != NULL);
   assert(repo != NULL);
   GitCommit* commit = ecalloc(1, sizeof(GitCommit));
   git_commit* gcommit = NULL;
   if (git_commit_lookup(&gcommit, repo, oid)) {
     errx(1, "git_commit_lookup");
   }
 
   // Get OID, parent OID.
   git_oid_tostr(commit->oid, sizeof(commit->oid), git_commit_id(gcommit));
   if (git_commit_parentcount(gcommit) > 0) {
     git_oid_tostr(commit->parentoid, sizeof(commit->parentoid),
                   git_commit_parent_id(gcommit, 0));
   } else {
     commit->parentoid[0] = '\0';
   }
 
   // Set commit summary, message.
   const char* summary = git_commit_summary(gcommit);
   commit->summary = summary ? estrdup(summary) : NULL;
   const char* message = git_commit_message(gcommit);
   commit->message = message ? estrdup(message) : NULL;
 
   // Get commit time, tz offset.
   commit->commit_time = git_commit_time(gcommit);
   commit->commit_timezone_offset = git_commit_time_offset(gcommit);
 
   // Get author info.
   const git_signature* author = git_commit_author(gcommit);
   commit->author_name = author->name ? estrdup(author->name) : NULL;
   commit->author_email = author->email ? estrdup(author->email) : NULL;
   commit->author_time = author->when.time;
   commit->author_timezone_offset = author->when.offset;
 
   // Look up commit tree.
   git_tree* commit_tree = NULL;
   if (git_tree_lookup(&commit_tree, repo, git_commit_tree_id(gcommit))) {
     errx(1, "git_tree_lookup");
   }
 
   // Look up parent tree, if there is a parent commit.
   git_commit* parent = NULL;
   git_tree* parent_tree = NULL;
   if (!git_commit_parent(&parent, gcommit, 0)) {
     if (git_tree_lookup(&parent_tree, repo, git_commit_tree_id(parent))) {
       errx(1, "git_tree_lookup");
     }
     git_commit_free(parent);
     parent = NULL;
   }
 
   // Compute the diff.
   git_diff* diff = NULL;
   git_diff_options opts;
   git_diff_options_init(&opts, GIT_DIFF_OPTIONS_VERSION);
   opts.flags |= GIT_DIFF_DISABLE_PATHSPEC_MATCH | GIT_DIFF_IGNORE_SUBMODULES |
                 GIT_DIFF_INCLUDE_TYPECHANGE;
   if (git_diff_tree_to_tree(&diff, repo, parent_tree, commit_tree, &opts)) {
     errx(1, "git_diff_tree_to_tree");
   }
   git_tree_free(commit_tree);
   git_tree_free(parent_tree);
 
   git_diff_find_options fopts;
   if (git_diff_find_options_init(&fopts, GIT_DIFF_FIND_OPTIONS_VERSION)) {
     errx(1, "git_diff_find_init_options");
   }
 
   /* find renames and copies, exact matches (no heuristic) for renames. */
   fopts.flags |= GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES |
                  GIT_DIFF_FIND_EXACT_MATCH_ONLY;
   if (git_diff_find_similar(diff, &fopts)) {
     errx(1, "git_diff_find_similar");
   }
 
   // Add deltas.
   commit->addcount = 0;
   commit->delcount = 0;
   size_t deltas_len = git_diff_num_deltas(diff);
   commit->deltas = ecalloc(deltas_len, sizeof(GitDelta*));
   size_t deltas_out_count = 0;
   for (size_t i = 0; i < deltas_len; i++) {
     git_patch* patch = NULL;
     if (git_patch_from_diff(&patch, diff, i)) {
       continue;
     }
 
     // Hand ownership of patch to delta.
     GitDelta* delta = gitdelta_create(patch);
     if (delta) {
       commit->deltas[deltas_out_count++] = delta;
       commit->addcount += delta->addcount;
       commit->delcount += delta->delcount;
     }
   }
   commit->deltas_len = deltas_out_count;
   commit->filecount = deltas_len;
 
   git_diff_free(diff);
   git_commit_free(gcommit);
   return commit;
 }
 
 void gitcommit_free(GitCommit* commit) {
   if (!commit) {
     return;
   }
   free(commit->summary);
   free(commit->message);
   free(commit->author_name);
   free(commit->author_email);
   for (size_t i = 0; i < commit->deltas_len; i++) {
     gitdelta_free(commit->deltas[i]);
     commit->deltas[i] = NULL;
   }
   free(commit->deltas);
   commit->deltas = NULL;
 
   free(commit);
 }