gitout

repo.c (13683B)

---

 #include "git/repo.h"
 
 #include <err.h>
 #include <git2/blob.h>
 #include <git2/commit.h>
 #include <git2/object.h>
 #include <git2/oid.h>
 #include <git2/refs.h>
 #include <git2/repository.h>
 #include <git2/revparse.h>
 #include <git2/revwalk.h>
 #include <git2/tree.h>
 #include <git2/types.h>
 #include <libgen.h>
 #include <limits.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/unistd.h>
 #include <unistd.h>
 
 #include "git/internal.h"
 #include "third_party/openbsd/reallocarray.h"
 #include "utils.h"
 
 struct GitRepo {
   char* name;
   char* short_name;
   char* owner;
   char* description;
   char* clone_url;
   const char* submodules;
   const char* readme;
   const char* license;
 
   void* repo;
 };
 
 /* Local const data */
 static const char* kLicenses[] = {"HEAD:LICENSE", "HEAD:LICENSE.md",
                                   "HEAD:COPYING"};
 static const size_t kLicensesLen = sizeof(kLicenses) / sizeof(char*);
 static const char* kReadmes[] = {"HEAD:README", "HEAD:README.md"};
 static const size_t kReadmesLen = sizeof(kReadmes) / sizeof(char*);
 
 /* Maximum file size to load into memory, in bytes. */
 static const ssize_t kMaxFileSizeBytes = 16 * 1024 * 1024;
 
 /* Utilities */
 static size_t string_count_lines(const char* str, ssize_t size_bytes);
 static bool string_ends_with(const char* str, const char* suffix);
 static char* first_line_of_file(const char* path);
 static const git_oid* oid_for_spec(git_repository* repo, const char* spec);
 static char* format_filemode(git_filemode_t m);
 
 /* GitRepo utilities. */
 static char* gitrepo_name_from_path(const char* repo_path);
 static char* gitrepo_shortname_from_name(const char* name);
 static bool gitrepo_has_blob(git_repository* repo, const char* file);
 static const char* gitrepo_first_matching_file(git_repository* repo,
                                                const char** files,
                                                size_t files_len);
 static bool gitrepo_walk_tree_files(git_repository* repo,
                                     git_tree* tree,
                                     const char* path,
                                     FileCallback cb,
                                     void* user_data);
 
 size_t string_count_lines(const char* str, ssize_t str_len) {
   if (str_len <= 0) {
     return 0;
   }
   size_t lines = 0;
   for (ssize_t i = 0; i < str_len; i++) {
     if (str[i] == '\n') {
       lines++;
     }
   }
   return str[str_len - 1] == '\n' ? lines : lines + 1;
 }
 
 bool string_ends_with(const char* str, const char* suffix) {
   if (!str || !suffix) {
     return false;
   }
   size_t str_len = strlen(str);
   size_t suffix_len = strlen(suffix);
   if (str_len < suffix_len) {
     return false;
   }
   return strncmp(str + str_len - suffix_len, suffix, suffix_len) == 0;
 }
 
 char* first_line_of_file(const char* path) {
   FILE* f = fopen(path, "r");
   if (!f) {
     return estrdup("");
   }
   char* buf = NULL;
   size_t buf_size = 0;
   size_t len = getline(&buf, &buf_size, f);
   fclose(f);
   if (!buf) {
     return estrdup("");
   }
   // Remove trailing newline.
   if (len > 0) {
     buf[len - 1] = '\0';
   }
   return buf;
 }
 
 const git_oid* oid_for_spec(git_repository* repo, const char* spec) {
   git_object* obj = NULL;
   if (git_revparse_single(&obj, repo, spec)) {
     return NULL;
   }
   const git_oid* oid = git_object_id(obj);
   git_object_free(obj);
   return oid;
 }
 
 char* format_filemode(git_filemode_t m) {
   char* mode = ecalloc(11, sizeof(char));
   memset(mode, '-', 10);
   mode[10] = '\0';
 
   if (S_ISREG(m)) {
     mode[0] = '-';
   } else if (S_ISBLK(m)) {
     mode[0] = 'b';
   } else if (S_ISCHR(m)) {
     mode[0] = 'c';
   } else if (S_ISDIR(m)) {
     mode[0] = 'd';
   } else if (S_ISFIFO(m)) {
     mode[0] = 'p';
   } else if (S_ISLNK(m)) {
     mode[0] = 'l';
   } else if (S_ISSOCK(m)) {
     mode[0] = 's';
   } else {
     mode[0] = '?';
   }
 
   if (m & S_IRUSR) {
     mode[1] = 'r';
   }
   if (m & S_IWUSR) {
     mode[2] = 'w';
   }
   if (m & S_IXUSR) {
     mode[3] = 'x';
   }
   if (m & S_IRGRP) {
     mode[4] = 'r';
   }
   if (m & S_IWGRP) {
     mode[5] = 'w';
   }
   if (m & S_IXGRP) {
     mode[6] = 'x';
   }
   if (m & S_IROTH) {
     mode[7] = 'r';
   }
   if (m & S_IWOTH) {
     mode[8] = 'w';
   }
   if (m & S_IXOTH) {
     mode[9] = 'x';
   }
 
   if (m & S_ISUID) {
     mode[3] = (mode[3] == 'x') ? 's' : 'S';
   }
   if (m & S_ISGID) {
     mode[6] = (mode[6] == 'x') ? 's' : 'S';
   }
   if (m & S_ISVTX) {
     mode[9] = (mode[9] == 'x') ? 't' : 'T';
   }
 
   return mode;
 }
 
 char* gitrepo_name_from_path(const char* repo_path) {
   char path[PATH_MAX];
   estrlcpy(path, repo_path, sizeof(path));
   const char* filename = basename(path);
   if (!filename) {
     err(1, "basename");
   }
   return estrdup(filename);
 }
 
 char* gitrepo_shortname_from_name(const char* name) {
   char* short_name = estrdup(name);
   if (string_ends_with(short_name, ".git")) {
     size_t short_name_len = strlen(short_name);
     size_t suffix_len = strlen(".git");
     short_name[short_name_len - suffix_len] = '\0';
   }
   return short_name;
 }
 
 bool gitrepo_has_blob(git_repository* repo, const char* file) {
   git_object* obj = NULL;
   if (git_revparse_single(&obj, repo, file)) {
     return false;
   }
   bool has_blob = git_object_type(obj) == GIT_OBJECT_BLOB;
   git_object_free(obj);
   return has_blob;
 }
 
 const char* gitrepo_first_matching_file(git_repository* repo,
                                         const char** files,
                                         size_t files_len) {
   for (size_t i = 0; i < files_len; i++) {
     const char* filename = files[i];
     if (gitrepo_has_blob(repo, filename)) {
       return filename + strlen("HEAD:");
     }
   }
   return "";
 }
 
 GitRepo* gitrepo_create(const char* path) {
   GitRepo* repo = ecalloc(1, sizeof(GitRepo));
   git_repository* git_repo = NULL;
   git_repository_open_flag_t kRepoOpenFlags = GIT_REPOSITORY_OPEN_NO_SEARCH;
   if (git_repository_open_ext(&git_repo, path, kRepoOpenFlags, NULL)) {
     errx(1, "git_repository_open_ext");
   }
   repo->repo = git_repo;
 
   char repo_path[PATH_MAX];
   if (!realpath(path, repo_path)) {
     err(1, "realpath");
   }
   char git_path[PATH_MAX];
   path_concat(git_path, sizeof(git_path), repo_path, ".git");
   if (access(git_path, F_OK) != 0) {
     estrlcpy(git_path, repo_path, sizeof(git_path));
   }
   char owner_path[PATH_MAX];
   path_concat(owner_path, sizeof(owner_path), git_path, "owner");
   char desc_path[PATH_MAX];
   path_concat(desc_path, sizeof(desc_path), git_path, "description");
   char url_path[PATH_MAX];
   path_concat(url_path, sizeof(url_path), git_path, "url");
 
   repo->name = gitrepo_name_from_path(repo_path);
   repo->short_name = gitrepo_shortname_from_name(repo->name);
   repo->owner = first_line_of_file(owner_path);
   repo->description = first_line_of_file(desc_path);
   repo->clone_url = first_line_of_file(url_path);
   repo->submodules = gitrepo_has_blob(repo->repo, "HEAD:.gitmodules")
                               ? ".gitmodules"
                               : "";
   repo->readme =
       gitrepo_first_matching_file(repo->repo, kReadmes, kReadmesLen);
   repo->license =
       gitrepo_first_matching_file(repo->repo, kLicenses, kLicensesLen);
   return repo;
 }
 
 void gitrepo_free(GitRepo* repo) {
   if (!repo) {
     return;
   }
   free(repo->name);
   repo->name = NULL;
   free(repo->short_name);
   repo->short_name = NULL;
   free(repo->owner);
   repo->owner = NULL;
   free(repo->description);
   repo->description = NULL;
   free(repo->clone_url);
   repo->clone_url = NULL;
   git_repository_free(repo->repo);
   repo->repo = NULL;
   free(repo);
 }
 
 const char* gitrepo_name(const GitRepo* repo) {
   return repo->name;
 }
 
 const char* gitrepo_short_name(const GitRepo* repo) {
   return repo->short_name;
 }
 
 const char* gitrepo_owner(const GitRepo* repo) {
   return repo->owner;
 }
 
 const char* gitrepo_description(const GitRepo* repo) {
   return repo->description;
 }
 
 const char* gitrepo_clone_url(const GitRepo* repo) {
   return repo->clone_url;
 }
 
 const char* gitrepo_submodules(const GitRepo* repo) {
   return repo->submodules;
 }
 
 const char* gitrepo_readme(const GitRepo* repo) {
   return repo->readme;
 }
 
 const char* gitrepo_license(const GitRepo* repo) {
   return repo->license;
 }
 
 void gitrepo_for_commit(GitRepo* repo,
                         const char* spec,
                         CommitCallback cb,
                         void* user_data) {
   const git_oid* start_oid = oid_for_spec(repo->repo, spec);
   if (start_oid == NULL) {
     return;
   }
 
   git_revwalk* revwalk = NULL;
   if (git_revwalk_new(&revwalk, repo->repo) != 0) {
     errx(1, "git_revwalk_new");
   }
   git_revwalk_push(revwalk, start_oid);
 
   git_oid current;
   if (!git_revwalk_next(&current, revwalk)) {
     GitCommit* commit = gitcommit_create(&current, repo->repo);
     cb(commit, user_data);
     gitcommit_free(commit);
   }
   git_revwalk_free(revwalk);
 }
 
 void gitrepo_for_each_commit(GitRepo* repo,
                              CommitCallback cb,
                              void* user_data) {
   const git_oid* start_oid = oid_for_spec(repo->repo, "HEAD");
 
   git_revwalk* revwalk = NULL;
   if (git_revwalk_new(&revwalk, repo->repo) != 0) {
     errx(1, "git_revwalk_new");
   }
   git_revwalk_push(revwalk, start_oid);
 
   git_oid current;
   while (!git_revwalk_next(&current, revwalk)) {
     GitCommit* commit = gitcommit_create(&current, repo->repo);
     cb(commit, user_data);
     gitcommit_free(commit);
   }
   git_revwalk_free(revwalk);
 }
 
 void gitrepo_for_each_reference(GitRepo* repo,
                                 ReferenceCallback cb,
                                 void* user_data) {
   git_reference_iterator* it = NULL;
   if (git_reference_iterator_new(&it, repo->repo) != 0) {
     errx(1, "git_reference_iterator_new");
   }
 
   GitReference** repos = NULL;
   size_t repos_len = 0;
   git_reference* current = NULL;
   while (!git_reference_next(&current, it)) {
     if (!git_reference_is_branch(current) && !git_reference_is_tag(current)) {
       git_reference_free(current);
       continue;
     }
     // Hand ownership of current to GitReference.
     GitReference* ref = gitreference_create(repo->repo, current);
     repos = reallocarray(repos, repos_len + 1, sizeof(GitReference*));
     if (!repos) {
       err(1, "reallocarray");
     }
     repos[repos_len++] = ref;
   }
   git_reference_iterator_free(it);
   qsort(repos, repos_len, sizeof(GitReference*), gitreference_compare);
 
   for (size_t i = 0; i < repos_len; i++) {
     cb(repos[i], user_data);
     gitreference_free(repos[i]);
     repos[i] = NULL;
   }
   free(repos);
 }
 
 bool gitrepo_walk_tree_files(git_repository* repo,
                              git_tree* tree,
                              const char* path,
                              FileCallback cb,
                              void* user_data) {
   for (size_t i = 0; i < git_tree_entrycount(tree); i++) {
     const git_tree_entry* entry = git_tree_entry_byindex(tree, i);
     if (!entry) {
       return false;
     }
 
     const char* entryname = git_tree_entry_name(entry);
     if (!entryname) {
       return false;
     }
 
     char entrypath[PATH_MAX];
     if (path[0] == '\0') {
       estrlcpy(entrypath, entryname, sizeof(entrypath));
     } else {
       char full_path[PATH_MAX];
       path_concat(full_path, sizeof(full_path), path, entryname);
       estrlcpy(entrypath, full_path, sizeof(entrypath));
     }
 
     git_object* obj = NULL;
     if (git_tree_entry_to_object(&obj, repo, entry) != 0) {
       char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
       git_oid_tostr(oid_str, sizeof(oid_str), git_tree_entry_id(entry));
       GitFile* fileinfo =
           gitfile_create(kFileTypeSubmodule, "m---------", entrypath,
                          ".gitmodules", oid_str, -1, -1, "");
       cb(fileinfo, user_data);
       gitfile_free(fileinfo);
     } else {
       switch (git_object_type(obj)) {
         case GIT_OBJECT_BLOB:
           break;
         case GIT_OBJECT_TREE: {
           /* NOTE: recurses */
           if (!gitrepo_walk_tree_files(repo, (git_tree*)obj, entrypath, cb,
                                        user_data)) {
             git_object_free(obj);
             return false;
           }
           git_object_free(obj);
           continue;
         }
         default:
           git_object_free(obj);
           continue;
       }
 
       git_blob* blob = (git_blob*)obj;
       ssize_t size_bytes = git_blob_rawsize(blob);
       ssize_t size_lines = -1;
       const char* content = "";
 
       if (size_bytes > kMaxFileSizeBytes) {
         size_lines = -2;  /* oversized file */
       } else if (!git_blob_is_binary(blob)) {
         content = (const char*)git_blob_rawcontent(blob);
         size_lines = string_count_lines(content, size_bytes);
       }
 
       char* filemode = format_filemode(git_tree_entry_filemode(entry));
       GitFile* fileinfo =
           gitfile_create(kFileTypeFile, filemode, entrypath, entrypath, "",
                          size_bytes, size_lines, content);
       cb(fileinfo, user_data);
       gitfile_free(fileinfo);
       git_object_free(obj);
       free(filemode);
     }
   }
   return true;
 }
 
 void gitrepo_for_each_file(GitRepo* repo,
                            FileCallback cb,
                            void* user_data) {
   git_commit* commit = NULL;
   const git_oid* id = oid_for_spec(repo->repo, "HEAD");
   if (git_commit_lookup(&commit, repo->repo, id) != 0) {
     return;
   }
   git_tree* tree = NULL;
   if (git_commit_tree(&tree, commit) != 0) {
     git_commit_free(commit);
     return;
   }
   git_commit_free(commit);
 
   if (!gitrepo_walk_tree_files(repo->repo, tree, "", cb, user_data)) {
     git_tree_free(tree);
     return;
   }
   git_tree_free(tree);
 }