Merge pull request #5 from diasbruno/feature/addition-deletion.

get all additions and deletion of a diff.

Author: diasbruno

include/diffstats/diffstats.h

@@ -5,8 +5,18 @@ enum diff_stats_err_t {
   HUNK_WITHOUT_DIFF = 1
 };
 
+enum diff_stats_line_t {
+  DIFF_NOTHING  = 0,
+  DIFF_HEADER   = 1,
+  HUNK_HEADER   = 2,
+  ADDITION_LINE = 3,
+  DELETION_LINE = 4
+};
+
 struct diff_stats_t {
   long  starts_at;
+  long  additions;
+  long  deletions;
   long  count;
   long  hunks;
   long* hunks_at;
@@ -18,15 +28,22 @@ struct diff_stats_t {
  * @param {long}  column - text column (updated every new line).
  * @return {int}
  */
-int diff_stats_is_diff_header(const char* text, long column);
+int diff_stats_is_diff_header(const char* text);
 
 /**
  * From the current point in text, is there a `@@`?
  * @param {char*} text   - the string.
  * @param {long}  column - text column (updated every new line).
  * @return {int}
  */
-int diff_stats_is_hunk_header(const char* text, long column);
+int diff_stats_is_hunk_header(const char* text);
+
+/**
+ * Find the type of the line.
+ * @param {const char*} text - text.
+ * @return {int}
+ */
+int diff_stats_line_type(const char* text);
 
 /**
  * Add a found hunk to the list.

src/diffstats.c

@@ -5,19 +5,35 @@
 
 static struct diff_stats_t* diff_stats_prepare_item(struct diff_stats_t* d) {
   d->starts_at = -1;
+  d->additions =  0;
+  d->deletions =  0;
   d->count     =  0;
   d->hunks     = 10;
   d->hunks_at  = (long*)malloc(sizeof(long) * 10);
   memset(d->hunks_at, 0, sizeof(long) * 10);
   return d;
 }
 
-int diff_stats_is_diff_header(const char* text, long column) {
-  return *text == 'd' && strncmp(text, (char*)"diff", 4) == 0 && column == 0;
+int diff_stats_is_diff_header(const char* text) {
+  return (*text == 'd' && strncmp(text, (char*)"diff", 4) == 0);
 }
 
-int diff_stats_is_hunk_header(const char* text, long column) {
-  return *text == '@' && strncmp(text, (char*)"@@", 2) == 0 && column == 0;
+int diff_stats_is_hunk_header(const char* text) {
+  return (*text == '@' && strncmp(text, (char*)"@@", 2) == 0);
+}
+
+int diff_stats_line_type(const char* text) {
+  if (diff_stats_is_diff_header(text)) {
+    return DIFF_HEADER;
+  }
+  if (diff_stats_is_hunk_header(text)) {
+    return HUNK_HEADER;
+  }
+  switch (*text) {
+  case '-': { return DELETION_LINE; } break;
+  case '+': { return ADDITION_LINE; } break;
+  default:  { return DIFF_NOTHING;  } break;
+  }
 }
 
 void diff_stats_add_hunk_at(struct diff_stats_t* d, long i) {
@@ -53,43 +69,61 @@ void diff_stats_free(struct diff_stats_t* d, long count) {
   free(d);
 }
 
+char* diff_stats_find_hunk(const char* str) {
+  char* text = (char*)str;
+  while (*text && *(text + 1)) {
+    if (*text == '\n' && *(text + 1) == '@') {
+      break;
+    }
+    text++;
+  }
+  return text;
+}
+
 struct diff_stats_t* diff_stats_parser(const char* str, long* counter, int* err) {
   char* hold   = (char*)str;
   char* text   = hold;
-  long  column = 0;
   long  index  = 0;
   long  count  = 12;
   struct diff_stats_t* diff =
     (struct diff_stats_t*)malloc(sizeof(struct diff_stats_t) * count);
   struct diff_stats_t* head = NULL;
 
   while (*text) {
-    if (diff_stats_is_diff_header(text, column)) {
+    int type = diff_stats_line_type(text);
+
+    switch (type) {
+    case DIFF_HEADER: {
       if (index + 1 <= count) {
         count += 12;
-        diff = (struct diff_stats_t*)realloc(diff, sizeof(struct diff_stats_t) * count);
+        diff = (struct diff_stats_t*)realloc(diff,
+                                             sizeof(struct diff_stats_t) * count);
       }
       head = diff_stats_prepare_item(diff + index);
       head->starts_at = (long)(text - hold);
       index++;
-    }
 
-    if (diff_stats_is_hunk_header(text, column)) {
+      text = diff_stats_find_hunk(text);
+      continue;
+    } break;
+    case HUNK_HEADER: {
       if (!head) {
         *err = HUNK_WITHOUT_DIFF;
         free(diff);
         diff = NULL;
         goto diff_stats_end;
       }
       diff_stats_add_hunk_at(head, (long)(text - hold));
+    } break;
+    case ADDITION_LINE: { head->additions++; goto diff_stats_skip; } break;
+    case DELETION_LINE: { head->deletions++; goto diff_stats_skip; } break;
+    default: {
+diff_stats_skip:
+      while (*text && *text != '\n') text++;
     }
-
-    if (*text == '\n') {
-      column = 0;
-    } else {
-      column++;
     }
-    ++text;
+
+    text++;
   }
 
   *err = 0;

tests/main.c

@@ -5,16 +5,16 @@
 #include <diffstats/diffstats.h>
 
 static void test_check_for_diff_header(void) {
-  int ok = diff_stats_is_diff_header("diff", 0);
+  int ok = diff_stats_is_diff_header("diff");
   assert(ok);
-  int fail = !diff_stats_is_diff_header("diff", 1);
+  int fail = !diff_stats_is_diff_header(" diff");
   assert(fail);
 }
 
 static void test_check_for_hunk_header(void) {
-  int ok = diff_stats_is_hunk_header("@@", 0);
+  int ok = diff_stats_is_hunk_header("@@");
   assert(ok);
-  int fail = !diff_stats_is_hunk_header("@@", 1);
+  int fail = !diff_stats_is_hunk_header(" @@");
   assert(fail);
 }
 
@@ -32,6 +32,8 @@ static void test_simple(void) {
   int err = 0;
   struct diff_stats_t* st = diff_stats_parser(diff_simple_test, &count, &err);
   assert(st[0].starts_at == 0);
+  assert(st[0].additions == 1);
+  assert(st[0].deletions == 1);
   assert(st[0].count == 1);
   free(st);
 }
@@ -69,6 +71,8 @@ static void test_with_2_hunks(void) {
   int err = 0;
   struct diff_stats_t* st = diff_stats_parser(diff_with_2_hunks_test, &count, &err);
   assert(st[0].starts_at == 0);
+  assert(st[0].additions == 4);
+  assert(st[0].deletions == 4);
   assert(st[0].count == 2);
   free(st);
 }
@@ -93,8 +97,13 @@ static void test_mixed(void) {
   int err = 0;
   struct diff_stats_t* st = diff_stats_parser(diff_mixed_test, &count, &err);
   assert(st[0].starts_at == 0);
+  assert(st[0].additions == 1);
+  assert(st[0].deletions == 1);
   assert(st[0].count == 1);
+
   assert(st[1].starts_at == 77);
+  assert(st[1].additions == 1);
+  assert(st[1].deletions == 1);
   assert(st[1].count == 1);
   free(st);
 }