gout

delta.c (5868B)

---

 #include "git/delta.h"
 
 #include <assert.h>
 #include <git2/diff.h>
 #include <git2/patch.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "git/internal.h"
 #include "utils.h"
 
 /* HunkLines */
 static GitHunkLine* githunkline_create(git_patch* patch,
                                        size_t hunk_id,
                                        size_t line_id);
 static void githunkline_free(GitHunkLine* hunk_line);
 
 /* Hunks */
 static GitHunk* githunk_create(git_patch* patch, size_t id);
 static void githunk_free(GitHunk* hunk);
 
 /* Deltas */
 static char status_for_delta(const git_diff_delta* delta);
 static char* gitdelta_graph(const GitDelta* delta,
                             size_t length,
                             char character,
                             size_t max_width);
 
 static GitHunkLine* githunkline_create(git_patch* patch,
                                        size_t hunk_id,
                                        size_t line_id) {
   assert(patch != NULL);
   const git_diff_line* line;
   if (git_patch_get_line_in_hunk(&line, patch, hunk_id, line_id)) {
     return NULL;
   }
 
   GitHunkLine* line_out = ecalloc(1, sizeof(GitHunkLine));
   line_out->id = line_id;
   line_out->old_lineno = line->old_lineno;
   line_out->new_lineno = line->new_lineno;
   line_out->content_len = line->content_len;
   line_out->content = ecalloc(line->content_len + 1, sizeof(char));
   memcpy(line_out->content, line->content, line->content_len);
   return line_out;
 }
 
 static void githunkline_free(GitHunkLine* hunk_line) {
   if (!hunk_line) {
     return;
   }
   free(hunk_line->content);
   free(hunk_line);
 }
 
 static GitHunk* githunk_create(git_patch* patch, size_t hunk_id) {
   assert(patch != NULL);
   const git_diff_hunk* hunk;
   size_t line_count;
   if (git_patch_get_hunk(&hunk, &line_count, patch, hunk_id)) {
     return NULL;
   }
 
   GitHunk* hunk_out = ecalloc(1, sizeof(GitHunk));
   hunk_out->id = hunk_id;
   hunk_out->header = estrdup(hunk->header);
   hunk_out->lines = ecalloc(line_count, sizeof(GitHunkLine*));
   size_t lines_out_count = 0;
   for (size_t i = 0; i < line_count; i++) {
     GitHunkLine* hunk_line = githunkline_create(patch, hunk_id, i);
     if (hunk_line) {
       hunk_out->lines[lines_out_count++] = hunk_line;
     }
   }
   hunk_out->lines_len = lines_out_count;
   return hunk_out;
 }
 
 static void githunk_free(GitHunk* hunk) {
   if (!hunk) {
     return;
   }
   free(hunk->header);
   for (size_t i = 0; i < hunk->lines_len; i++) {
     githunkline_free(hunk->lines[i]);
     hunk->lines[i] = NULL;
   }
   free(hunk->lines);
   hunk->lines = NULL;
   free(hunk);
 }
 
 static char status_for_delta(const git_diff_delta* delta) {
   assert(delta != NULL);
   switch (delta->status) {
     case GIT_DELTA_ADDED:
       return 'A';
     case GIT_DELTA_COPIED:
       return 'C';
     case GIT_DELTA_DELETED:
       return 'D';
     case GIT_DELTA_MODIFIED:
       return 'M';
     case GIT_DELTA_RENAMED:
       return 'R';
     case GIT_DELTA_TYPECHANGE:
       return 'T';
     case GIT_DELTA_CONFLICTED:
     case GIT_DELTA_IGNORED:
     case GIT_DELTA_UNMODIFIED:
     case GIT_DELTA_UNREADABLE:
     case GIT_DELTA_UNTRACKED:
       return ' ';
   }
   return ' ';
 }
 
 GitDelta* gitdelta_create(git_patch* patch) {
   assert(patch != NULL);
   GitDelta* delta = ecalloc(1, sizeof(GitDelta));
 
   const git_diff_delta* git_delta = git_patch_get_delta(patch);
   delta->status = status_for_delta(git_delta);
   delta->is_binary = git_delta->flags & GIT_DIFF_FLAG_BINARY;
   delta->old_file_path =
       git_delta->old_file.path ? estrdup(git_delta->old_file.path) : NULL;
   delta->new_file_path =
       git_delta->new_file.path ? estrdup(git_delta->new_file.path) : NULL;
   delta->addcount = 0;
   delta->delcount = 0;
 
   /* Skip stats for binary data. */
   if (delta->is_binary) {
     git_patch_free(patch);
     return delta;
   }
 
   /* Populate hunks array. */
   size_t hunk_count = git_patch_num_hunks(patch);
   delta->hunks = ecalloc(hunk_count, sizeof(GitHunk*));
   size_t hunks_out_count = 0;
   for (size_t i = 0; i < hunk_count; i++) {
     const git_diff_hunk* hunk;
     size_t line_count;
     if (!git_patch_get_hunk(&hunk, &line_count, patch, i)) {
       GitHunk* hunk = githunk_create(patch, i);
       if (hunk) {
         delta->hunks[hunks_out_count++] = hunk;
       }
     }
   }
   delta->hunks_len = hunks_out_count;
 
   /* Increment added/deleted line counts. */
   for (size_t i = 0; i < delta->hunks_len; i++) {
     GitHunk* hunk = delta->hunks[i];
     for (size_t j = 0; j < hunk->lines_len; j++) {
       GitHunkLine* line = hunk->lines[j];
       if (line->old_lineno == -1) {
         delta->addcount++;
       } else if (line->new_lineno == -1) {
         delta->delcount++;
       }
     }
   }
   git_patch_free(patch);
   return delta;
 }
 
 void gitdelta_free(GitDelta* delta) {
   if (!delta) {
     return;
   }
   free(delta->old_file_path);
   free(delta->new_file_path);
   for (size_t i = 0; i < delta->hunks_len; i++) {
     githunk_free(delta->hunks[i]);
     delta->hunks[i] = NULL;
   }
   free(delta->hunks);
   delta->hunks = NULL;
   free(delta);
 }
 
 static char* gitdelta_graph(const GitDelta* delta,
                             size_t length,
                             char c,
                             size_t max_width) {
   assert(delta != NULL);
   size_t changed = delta->addcount + delta->delcount;
   if (changed > max_width && length > 0) {
     length = (length * max_width) / changed;
     if (length == 0) {
       length = 1;
     }
   }
   char* graph = ecalloc(length + 1, sizeof(char));
   memset(graph, c, length);
   return graph;
 }
 
 char* gitdelta_added_graph(const GitDelta* delta, size_t max_width) {
   assert(delta != NULL);
   return gitdelta_graph(delta, delta->addcount, '+', max_width);
 }
 
 char* gitdelta_deleted_graph(const GitDelta* delta, size_t max_width) {
   assert(delta != NULL);
   return gitdelta_graph(delta, delta->delcount, '-', max_width);
 }