gout

refs.c (5220B)

---

 #include "writer/html/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/html/page.h"
 
 typedef struct {
   char* title;
   char* id;
   FILE* out;
 } HtmlRefsTable;
 
 typedef struct {
   char* shorthand;
   time_t author_time;
   char* author_name;
 } RefData;
 
 typedef struct {
   RefData* items;
   size_t count;
   size_t capacity;
 } RefList;
 
 struct HtmlRefs {
   const GitRepo* repo;
   const FileSystem* fs;
   FILE* out;
   HtmlPage* page;
   RefList branches;
   RefList tags;
 };
 
 static HtmlRefsTable* html_refstable_create(const char* title,
                                             const char* id,
                                             FILE* out);
 static void html_refstable_free(HtmlRefsTable* table);
 static void html_refstable_begin(HtmlRefsTable* table);
 static void html_refstable_add_ref(HtmlRefsTable* table, const RefData* ref);
 static void html_refstable_end(HtmlRefsTable* table);
 
 static HtmlRefsTable* html_refstable_create(const char* title,
                                             const char* id,
                                             FILE* out) {
   assert(title != NULL);
   assert(id != NULL);
   assert(out != NULL);
   HtmlRefsTable* table = ecalloc(1, sizeof(HtmlRefsTable));
   table->title = estrdup(title);
   table->id = estrdup(id);
   table->out = out;
   return table;
 }
 
 static void html_refstable_free(HtmlRefsTable* table) {
   if (!table) {
     return;
   }
   free(table->title);
   free(table->id);
   free(table);
 }
 
 static void html_refstable_begin(HtmlRefsTable* table) {
   assert(table != NULL);
   fprintf(table->out, "<h2>%s</h2>", table->title);
   fprintf(table->out, "<table id=\"%s\">", table->id);
   fprintf(table->out,
           "<thead>\n"
           "<tr>"
           "<td><b>Name</b></td>"
           "<td><b>Last commit date</b></td>"
           "<td><b>Author</b></td>\n"
           "</tr>\n"
           "</thead><tbody>\n");
 }
 
 static void html_refstable_add_ref(HtmlRefsTable* table, const RefData* ref) {
   assert(table != NULL);
   assert(ref != NULL);
   fprintf(table->out, "<tr><td>");
   print_xml_encoded(table->out, ref->shorthand);
   fprintf(table->out, "</td><td>");
   print_time_short(table->out, ref->author_time);
   fprintf(table->out, "</td><td>");
   print_xml_encoded(table->out, ref->author_name);
   fprintf(table->out, "</td></tr>\n");
 }
 
 static void html_refstable_end(HtmlRefsTable* table) {
   assert(table != NULL);
   fprintf(table->out, "</tbody></table><br/>\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;
 }
 
 HtmlRefs* html_refs_create(const GitRepo* repo, const FileSystem* fs) {
   assert(repo != NULL);
   assert(fs != NULL);
   HtmlRefs* refs = ecalloc(1, sizeof(HtmlRefs));
   refs->repo = repo;
   refs->fs = fs;
   refs->out = fs->fopen("refs.html", "w");
   if (!refs->out) {
     err(1, "fopen: refs.html");
   }
   refs->page = html_page_create(refs->out, repo, fs, "Refs", "");
   return refs;
 }
 
 void html_refs_free(HtmlRefs* refs) {
   if (!refs) {
     return;
   }
   refs->fs->fclose(refs->out);
   html_page_free(refs->page);
   reflist_clear(&refs->branches);
   reflist_clear(&refs->tags);
   free(refs);
 }
 
 void html_refs_begin(HtmlRefs* refs) {
   assert(refs != NULL);
   html_page_begin(refs->page);
 }
 
 void html_refs_add_ref(HtmlRefs* 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 html_refs_end(HtmlRefs* refs) {
   assert(refs != NULL);
   if (refs->branches.count > 0) {
     HtmlRefsTable* table =
         html_refstable_create("Branches", "branches", refs->out);
     html_refstable_begin(table);
     for (size_t i = 0; i < refs->branches.count; i++) {
       html_refstable_add_ref(table, &refs->branches.items[i]);
     }
     html_refstable_end(table);
     html_refstable_free(table);
   }
   if (refs->tags.count > 0) {
     HtmlRefsTable* table = html_refstable_create("Tags", "tags", refs->out);
     html_refstable_begin(table);
     for (size_t i = 0; i < refs->tags.count; i++) {
       html_refstable_add_ref(table, &refs->tags.items[i]);
     }
     html_refstable_end(table);
     html_refstable_free(table);
   }
   html_page_end(refs->page);
 }