gitout

commit.c (5865B)

---

 #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"
 #include "utils.h"
 
 struct GitCommit {
   char* oid;
   char* parentoid;
   const char* summary;
   const char* message;
   time_t commit_time;
   int commit_timezone_offset;
   const char* author_name;
   const char* author_email;
   time_t author_time;
   int author_timezone_offset;
   GitDelta** deltas;
   size_t deltas_len;
   size_t addcount;
   size_t delcount;
   size_t filecount;
 
   git_commit* commit;
   git_diff* diff;
 };
 
 GitCommit* gitcommit_create(const git_oid* oid, git_repository* repo) {
   GitCommit* commit = ecalloc(1, sizeof(GitCommit));
   if (git_commit_lookup(&commit->commit, repo, oid)) {
     errx(1, "git_commit_lookup");
   }
 
   // Get OID, parent OID.
   commit->oid = ecalloc(GIT_OID_SHA1_HEXSIZE + 1, sizeof(char));
   git_oid_tostr(commit->oid, GIT_OID_SHA1_HEXSIZE + 1,
                 git_commit_id(commit->commit));
   commit->parentoid = ecalloc(GIT_OID_SHA1_HEXSIZE + 1, sizeof(char));
   git_oid_tostr(commit->parentoid, GIT_OID_SHA1_HEXSIZE + 1,
                 git_commit_parent_id(commit->commit, 0));
 
   // Set commit summary, message.
   commit->summary = git_commit_summary(commit->commit);
   commit->message = git_commit_message(commit->commit);
 
   // Get commit time, tz offset.
   commit->commit_time = git_commit_time(commit->commit);
   commit->commit_timezone_offset = git_commit_time_offset(commit->commit);
 
   // Get author info.
   const git_signature* author = git_commit_author(commit->commit);
   commit->author_name = author->name;
   commit->author_email = author->email;
   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(commit->commit))) {
     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, commit->commit, 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_free(commit->diff);
   commit->diff = diff;
 
   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(commit->diff, &fopts)) {
     errx(1, "git_diff_find_similar");
   }
 
   // Add deltas.
   commit->addcount = 0;
   commit->delcount = 0;
   size_t deltas_len = git_diff_num_deltas(commit->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, commit->diff, i)) {
       continue;
     }
 
     // Hand ownership of patch to delta.
     GitDelta* delta = gitdelta_create(patch);
     if (delta) {
       commit->deltas[deltas_out_count++] = delta;
       commit->addcount += gitdelta_lines_added(delta);
       commit->delcount += gitdelta_lines_deleted(delta);
     }
   }
   commit->deltas_len = deltas_out_count;
   commit->filecount = deltas_len;
   return commit;
 }
 
 void gitcommit_free(GitCommit* commit) {
   if (!commit) {
     return;
   }
   free(commit->oid);
   free(commit->parentoid);
   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;
 
   git_diff_free(commit->diff);
   commit->diff = NULL;
   git_commit_free(commit->commit);
   commit->commit = NULL;
   free(commit);
 }
 
 const char* gitcommit_oid(const GitCommit* commit) {
   return commit->oid;
 }
 
 const char* gitcommit_parentoid(const GitCommit* commit) {
   return commit->parentoid;
 }
 
 const char* gitcommit_summary(const GitCommit* commit) {
   return commit->summary;
 }
 
 const char* gitcommit_message(const GitCommit* commit) {
   return commit->message;
 }
 
 time_t gitcommit_commit_time(const GitCommit* commit) {
   return commit->commit_time;
 }
 
 int gitcommit_commit_timezone_offset(const GitCommit* commit) {
   return commit->commit_timezone_offset;
 }
 
 const char* gitcommit_author_name(const GitCommit* commit) {
   return commit->author_name;
 }
 
 const char* gitcommit_author_email(const GitCommit* commit) {
   return commit->author_email;
 }
 
 time_t gitcommit_author_time(const GitCommit* commit) {
   return commit->author_time;
 }
 
 int gitcommit_author_timezone_offset(const GitCommit* commit) {
   return commit->author_timezone_offset;
 }
 
 GitDelta* gitcommit_delta(const GitCommit* commit, size_t index) {
   assert(index < commit->deltas_len);
   return commit->deltas[index];
 }
 
 size_t gitcommit_delta_count(const GitCommit* commit) {
   return commit->deltas_len;
 }
 
 size_t gitcommit_addcount(const GitCommit* commit) {
   return commit->addcount;
 }
 
 size_t gitcommit_delcount(const GitCommit* commit) {
   return commit->delcount;
 }
 
 size_t gitcommit_filecount(const GitCommit* commit) {
   return commit->filecount;
 }