gout

refs.c (5250B)

---

 #include "writer/gopher/refs.h"
 
 #include <assert.h>
 #include <err.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "format.h"
 #include "git/commit.h"
 #include "third_party/openbsd/reallocarray.h"
 #include "utils.h"
 #include "writer/gopher/page.h"
 
 typedef struct {
   char* title;
   char* id;
   FILE* out;
 } GopherRefsTable;
 
 typedef struct {
   char* shorthand;
   time_t author_time;
   char* author_name;
 } RefData;
 
 typedef struct {
   RefData* items;
   size_t count;
   size_t capacity;
 } RefList;
 
 struct GopherRefs {
   const GitRepo* repo;
   const FileSystem* fs;
   FILE* out;
   GopherPage* page;
   RefList branches;
   RefList tags;
 };
 
 static GopherRefsTable* gopher_refstable_create(const char* title,
                                                 const char* id,
                                                 FILE* out);
 static void gopher_refstable_free(GopherRefsTable* table);
 static void gopher_refstable_begin(GopherRefsTable* table);
 static void gopher_refstable_add_ref(GopherRefsTable* table,
                                      const RefData* ref);
 static void gopher_refstable_end(GopherRefsTable* table);
 
 static GopherRefsTable* gopher_refstable_create(const char* title,
                                                 const char* id,
                                                 FILE* out) {
   assert(title != NULL);
   assert(id != NULL);
   assert(out != NULL);
   GopherRefsTable* table = ecalloc(1, sizeof(GopherRefsTable));
   table->title = estrdup(title);
   table->id = estrdup(id);
   table->out = out;
   return table;
 }
 
 static void gopher_refstable_free(GopherRefsTable* table) {
   if (!table) {
     return;
   }
   free(table->title);
   free(table->id);
   free(table);
 }
 
 static void gopher_refstable_begin(GopherRefsTable* table) {
   assert(table != NULL);
   FILE* out = table->out;
   fprintf(out, "%s\n", table->title);
   fprintf(out, "  %-32.32s", "Name");
   fprintf(out, "  %-16.16s", "Last commit date");
   fprintf(out, "  %s\n", "Author");
 }
 
 static void gopher_refstable_add_ref(GopherRefsTable* table,
                                      const RefData* ref) {
   assert(table != NULL);
   assert(ref != NULL);
   FILE* out = table->out;
 
   fprintf(out, "  ");
   print_gopher_link_padded(out, ref->shorthand, 32, ' ');
   fprintf(out, "  ");
   print_time_short(out, ref->author_time);
   fprintf(out, "  ");
   print_gopher_link_padded(out, ref->author_name, 25, '\0');
   fprintf(out, "\n");
 }
 
 static void gopher_refstable_end(GopherRefsTable* table) {
   assert(table != NULL);
   FILE* out = table->out;
   fprintf(out, "\n");
 }
 
 static void reflist_add(RefList* list, const GitReference* ref) {
   if (list->count >= list->capacity) {
     list->capacity = list->capacity == 0 ? 16 : list->capacity * 2;
     list->items = reallocarray(list->items, list->capacity, sizeof(RefData));
     if (!list->items) {
       err(1, "reallocarray");
     }
   }
   RefData* item = &list->items[list->count++];
   item->shorthand = estrdup(ref->shorthand);
   if (ref->commit) {
     item->author_time = ref->commit->author_time;
     item->author_name = estrdup(ref->commit->author_name);
   } else {
     item->author_time = 0;
     item->author_name = estrdup("");
   }
 }
 
 static void reflist_clear(RefList* list) {
   for (size_t i = 0; i < list->count; i++) {
     free(list->items[i].shorthand);
     free(list->items[i].author_name);
   }
   free(list->items);
   list->items = NULL;
   list->count = 0;
   list->capacity = 0;
 }
 
 GopherRefs* gopher_refs_create(const GitRepo* repo, const FileSystem* fs) {
   assert(repo != NULL);
   assert(fs != NULL);
   GopherRefs* refs = ecalloc(1, sizeof(GopherRefs));
   refs->repo = repo;
   refs->fs = fs;
   refs->out = fs->fopen("refs.gph", "w");
   if (!refs->out) {
     err(1, "fopen: refs.gph");
   }
   refs->page = gopher_page_create(refs->out, repo, fs, "Refs", "");
   return refs;
 }
 
 void gopher_refs_free(GopherRefs* refs) {
   if (!refs) {
     return;
   }
   refs->fs->fclose(refs->out);
   gopher_page_free(refs->page);
   reflist_clear(&refs->branches);
   reflist_clear(&refs->tags);
   free(refs);
 }
 
 void gopher_refs_begin(GopherRefs* refs) {
   assert(refs != NULL);
   gopher_page_begin(refs->page);
 }
 
 void gopher_refs_add_ref(GopherRefs* refs, const GitReference* ref) {
   assert(refs != NULL);
   assert(ref != NULL);
   switch (ref->type) {
     case kReftypeBranch:
       reflist_add(&refs->branches, ref);
       break;
     case kReftypeTag:
       reflist_add(&refs->tags, ref);
       break;
   }
 }
 
 void gopher_refs_end(GopherRefs* refs) {
   assert(refs != NULL);
   if (refs->branches.count > 0) {
     GopherRefsTable* table =
         gopher_refstable_create("Branches", "branches", refs->out);
     gopher_refstable_begin(table);
     for (size_t i = 0; i < refs->branches.count; i++) {
       gopher_refstable_add_ref(table, &refs->branches.items[i]);
     }
     gopher_refstable_end(table);
     gopher_refstable_free(table);
   }
   if (refs->tags.count > 0) {
     GopherRefsTable* table = gopher_refstable_create("Tags", "tags", refs->out);
     gopher_refstable_begin(table);
     for (size_t i = 0; i < refs->tags.count; i++) {
       gopher_refstable_add_ref(table, &refs->tags.items[i]);
     }
     gopher_refstable_end(table);
     gopher_refstable_free(table);
   }
   gopher_page_end(refs->page);
 }