feat: git version control for backup

src/main.c

@@ -96,9 +96,21 @@ int main(int argc, char *argv[]) {
     debug("Parsing the JSON config");
 
     cJSON *json = cJSON_Parse(data);
-    if (!json) {
-        free(data);
-    }
+
+  if (!json) {
+      const char *error_ptr = cJSON_GetErrorPtr();
+  
+      if (error_ptr) {
+          error(
+              1,
+              "program",
+              "JSON parse error near: %.30s",
+              error_ptr
+          );
+      }
+  
+      free(data);
+  }
     error(!json, "program", "JSON parse error");
 
     // Parse all of the directories which will( or do) contain the vaults
@@ -210,6 +222,9 @@ int main(int argc, char *argv[]) {
     char **backupDirectoriesArray = malloc(numDirectories * sizeof(char *));
     char **rsyncArgs = NULL;
     int rsyncArgsNumber = 0;
+    int gitEnabled = 0;
+    char *gitSignatureName = NULL;
+    char *gitSignatureEmail = NULL;
     cJSON *backupJSON = cJSON_GetObjectItem(json, "backup");
     if (backupJSON && cJSON_IsObject(backupJSON)) {
         cJSON *doesBackupJSON = cJSON_GetObjectItem(backupJSON, "enable");
@@ -285,11 +300,36 @@ int main(int argc, char *argv[]) {
                       "value is from an unexpected type",
                       configPath);
             }
+
+            // Configure Git backup
+            cJSON *gitJSON = cJSON_GetObjectItem(backupJSON, "git");
+            
+            if (gitJSON && cJSON_IsObject(gitJSON)) {
+                cJSON *gitEnableJSON = cJSON_GetObjectItem(gitJSON, "enable");
+                cJSON *gitNameJSON = cJSON_GetObjectItem(gitJSON, "name");
+                cJSON *gitEmailJSON = cJSON_GetObjectItem(gitJSON, "email");
+            
+                error(!gitEnableJSON || !cJSON_IsBool(gitEnableJSON), "user", "Entry \"git.enable\" in %s must be a bool.", configPath);
+                error(!gitNameJSON || !cJSON_IsString(gitNameJSON), "user", "Entry \"git.name\" in %s must be a string.", configPath);
+                error(!gitEmailJSON || !cJSON_IsString(gitEmailJSON), "user", "Entry \"git.email\" in %s must be a string.", configPath);
+            
+                gitEnabled = cJSON_IsTrue(gitEnableJSON) ? 1 : 0;
+            
+                if (gitEnabled) {
+                    gitSignatureName = strdup(cJSON_GetStringValue(gitNameJSON));
+                    gitSignatureEmail = strdup(cJSON_GetStringValue(gitEmailJSON));
+            
+                    error(gitSignatureName == NULL || gitSignatureEmail == NULL, "program", "malloc failed");
+            
+                    debug("git in %s is enabled with name \"%s\" and email \"%s\"", configPath, gitSignatureName, gitSignatureEmail);
+                } else {
+                    debug("git in %s is disabled", configPath);
+                }
+            } else {
+                error(1, "user", "Entry \"git\" in %s must be an object containing \"enable\", \"name\", and \"email\".", configPath);
+            }
         } else {
-            error(1, "user",
-                  "%s did not contained a enable value inside the backup section or the value is "
-                  "from an unexpected type",
-                  configPath);
+            error(1, "user", "%s did not contained a enable value inside the backup section or the value is from an unexpected type", configPath);
         }
         // handle rsyncs array of arguments.
         cJSON *rsyncArgsJSON = cJSON_GetObjectItem(backupJSON, "rsyncArgs");
@@ -314,9 +354,7 @@ int main(int argc, char *argv[]) {
                   configPath);
         }
     } else {
-        debug("In %s, \"backup\" wasn't set or we encountered a abnormal type. Defaulting to "
-              "{\"enable\": false}.",
-              configPath);
+        debug("In %s, \"backup\" wasn't set or we encountered a abnormal type. Defaulting to {\"enable\": false}.", configPath);
     }
 backup_config_end:
 
@@ -541,6 +579,12 @@ backup_config_end:
 
     initscr(); // initialize ncurses
 
+    // initialized libgit2
+    if (gitEnabled) {
+      int libgit2InitializationTimes = git_libgit2_init();
+      error(libgit2InitializationTimes != 1, "program", "libgit2 has been initialized %d times (instead of one)", libgit2InitializationTimes);
+    }
+
     int shouldExit = 0;
     while (!shouldExit) {
         // this loop is the vault selector
@@ -620,6 +664,11 @@ backup_config_end:
             int shouldChangeVault = 0;
             // we must find the directory from which the vault comes again.
             char *notesDirectoryString = getDirectoryFromVault(vaultSelected, vaultsArray, vaultsCount, vaultsCountForEachDirectory, directoriesArray, numDirectories, shouldDebug);
+
+            if (gitEnabled) { // we check if we need to git init the vault each time we enter it
+                  ensureGitDirectory(notesDirectoryString, vaultSelected, gitSignatureName, gitSignatureEmail, shouldDebug);
+            }
+
             while (!shouldExit && !shouldChangeVault) {
                 // this loop is the note selector
                 int filesCount = 0;
@@ -712,6 +761,14 @@ backup_config_end:
                         appendToFile(fullPath, "\n", shouldDebug);
                     }
                     openEditor(fullPath, editorToOpen, shouldRender, shouldJumpToEnd, shouldDebug);
+                    if (gitEnabled) { // After closing a file, we need to update the git repo (if git is enable
+                      char *date = getDateAndTime();
+                      char *commitMsg = malloc(29);
+                      snprintf(commitMsg, 29, "Update - %s", date);
+                      gitBackupUpdate(notesDirectoryString, vaultSelected, gitSignatureName, gitSignatureEmail, commitMsg, shouldDebug);
+                      free(date);
+                      free(commitMsg);
+                    }
                     free(fullPath);
                 } else if (strcmp(noteSelected, "Create new note") == 0) {
                 note_creation: