gout

refs.c (4907B)

---

 #include "writer/gemini/refs.h"
 
 #include <assert.h>
 #include <err.h>
 #include <stdbool.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/gemini/page.h"
 
 typedef struct {
   char* title;
   FILE* out;
 } GeminiRefsTable;
 
 typedef struct {
   char* shorthand;
   time_t author_time;
   char* author_name;
 } RefData;
 
 typedef struct {
   RefData* items;
   size_t count;
   size_t capacity;
 } RefList;
 
 struct GeminiRefs {
   const GitRepo* repo;
   const FileSystem* fs;
   FILE* out;
   GeminiPage* page;
   RefList branches;
   RefList tags;
 };
 
 static GeminiRefsTable* gemini_refstable_create(const char* title, FILE* out);
 static void gemini_refstable_free(GeminiRefsTable* table);
 static void gemini_refstable_begin(GeminiRefsTable* table);
 static void gemini_refstable_add_ref(GeminiRefsTable* table,
                                      const RefData* ref);
 static void gemini_refstable_end(GeminiRefsTable* table);
 
 static GeminiRefsTable* gemini_refstable_create(const char* title, FILE* out) {
   assert(title != NULL);
   assert(out != NULL);
   GeminiRefsTable* table = ecalloc(1, sizeof(GeminiRefsTable));
   table->title = estrdup(title);
   table->out = out;
   return table;
 }
 
 static void gemini_refstable_free(GeminiRefsTable* table) {
   if (!table) {
     return;
   }
   free(table->title);
   free(table);
 }
 
 static void gemini_refstable_begin(GeminiRefsTable* table) {
   assert(table != NULL);
   fprintf(table->out, "## %s\n\n", table->title);
   fprintf(table->out, "```\n");
   print_utf8_padded(table->out, "Name", 32, ' ');
   fprintf(table->out, "  ");
   print_utf8_padded(table->out, "Last commit date", 16, ' ');
   fprintf(table->out, "  Author\n");
 }
 
 static void gemini_refstable_add_ref(GeminiRefsTable* table,
                                      const RefData* ref) {
   assert(table != NULL);
   assert(ref != NULL);
   FILE* out = table->out;
 
   print_utf8_padded(out, ref->shorthand, 32, ' ');
   fprintf(out, "  ");
   print_time_short(out, ref->author_time);
   fprintf(out, "  %s\n", ref->author_name);
 }
 
 static void gemini_refstable_end(GeminiRefsTable* table) {
   assert(table != NULL);
   fprintf(table->out, "```\n\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;
 }
 
 GeminiRefs* gemini_refs_create(const GitRepo* repo, const FileSystem* fs) {
   assert(repo != NULL);
   assert(fs != NULL);
   GeminiRefs* refs = ecalloc(1, sizeof(GeminiRefs));
   refs->repo = repo;
   refs->fs = fs;
   refs->out = fs->fopen("refs.gmi", "w");
   if (!refs->out) {
     err(1, "fopen: refs.gmi");
   }
   refs->page = gemini_page_create(refs->out, repo, fs, "Refs", "");
   return refs;
 }
 
 void gemini_refs_free(GeminiRefs* refs) {
   if (!refs) {
     return;
   }
   refs->fs->fclose(refs->out);
   gemini_page_free(refs->page);
   reflist_clear(&refs->branches);
   reflist_clear(&refs->tags);
   free(refs);
 }
 
 void gemini_refs_begin(GeminiRefs* refs) {
   assert(refs != NULL);
   gemini_page_begin(refs->page);
 }
 
 void gemini_refs_add_ref(GeminiRefs* 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 gemini_refs_end(GeminiRefs* refs) {
   assert(refs != NULL);
   if (refs->branches.count > 0) {
     GeminiRefsTable* table = gemini_refstable_create("Branches", refs->out);
     gemini_refstable_begin(table);
     for (size_t i = 0; i < refs->branches.count; i++) {
       gemini_refstable_add_ref(table, &refs->branches.items[i]);
     }
     gemini_refstable_end(table);
     gemini_refstable_free(table);
   }
   if (refs->tags.count > 0) {
     GeminiRefsTable* table = gemini_refstable_create("Tags", refs->out);
     gemini_refstable_begin(table);
     for (size_t i = 0; i < refs->tags.count; i++) {
       gemini_refstable_add_ref(table, &refs->tags.items[i]);
     }
     gemini_refstable_end(table);
     gemini_refstable_free(table);
   }
   gemini_page_end(refs->page);
 }