Experimental Markdown rendering

Convert Markdown to Gemtext and use ANSI escape sequences to switch fonts (bold, italic, monospace). The conversion is still a bit buggy...

5 files changed, 224 insertions, 3 deletions

diff --git a/src/defs.h b/src/defs.h
index f5479cf3..40e134c9 100644
--- a/src/defs.h
+++ b/src/defs.h
@@ -28,6 +28,7 @@ enum iSourceFormat {
     undefined_SourceFormat = -1,
     gemini_SourceFormat    = 0,
     plainText_SourceFormat,
+    markdown_SourceFormat,
 };
 
 enum iFileVersion {
diff --git a/src/gmdocument.c b/src/gmdocument.c
index 508047a6..f0d9bf08 100644
--- a/src/gmdocument.c
+++ b/src/gmdocument.c
@@ -1712,8 +1712,183 @@ void setUrl_GmDocument(iGmDocument *d, const iString *url) {
     updateIconBasedOnUrl_GmDocument_(d);
 }
 
+static int replaceRegExp_String(iString *d, const iRegExp *regexp, const char *replacement,
+                                void (*matchHandler)(void *, const iRegExpMatch *),
+                                void *context) {
+    iRegExpMatch m;
+    iString      result;
+    int          numMatches = 0;
+    const char  *pos        = constBegin_String(d);
+    init_RegExpMatch(&m);
+    init_String(&result);
+    while (matchString_RegExp(regexp, d, &m)) {
+        appendRange_String(&result, (iRangecc){ pos, begin_RegExpMatch(&m) });
+        /* Replace any capture group back-references. */
+        for (const char *ch = replacement; *ch; ch++) {
+            if (*ch == '\\') {
+                ch++;
+                if (*ch == '\\') {
+                    appendCStr_String(&result, "\\");
+                }
+                else if (*ch >= '0' && *ch <= '9') {
+                    appendRange_String(&result, capturedRange_RegExpMatch(&m, *ch - '0'));
+                }
+            }
+            else {
+                appendData_Block(&result.chars, ch, 1);
+            }
+        }
+        if (matchHandler) {
+            matchHandler(context, &m);
+        }
+        pos = end_RegExpMatch(&m);
+        numMatches++;
+    }
+    appendRange_String(&result, (iRangecc){ pos, constEnd_String(d) });
+    set_String(d, &result);
+    deinit_String(&result);
+    return numMatches;
+}
+
+iDeclareType(PendingLink)
+struct Impl_PendingLink {
+    iString *url;
+    iString *title;
+};
+
+static void addPendingLink_(void *context, const iRegExpMatch *m) {
+    pushBack_Array(context, &(iPendingLink){
+        .url   = captured_RegExpMatch(m, 2),
+        .title = captured_RegExpMatch(m, 1)
+    });
+}
+
+static void addPendingNamedLink_(void *context, const iRegExpMatch *m) {
+    pushBack_Array(context, &(iPendingLink){
+        .url   = newFormat_String("[]%s", cstr_Rangecc(capturedRange_RegExpMatch(m, 2))),
+        .title = captured_RegExpMatch(m, 1)
+    });
+}
+
+static void flushPendingLinks_(iArray *links, const iString *source, iString *out) {
+    iRegExp *namePattern = new_RegExp("\n\\s*\\[(.+?)\\]\\s*:\\s*([^\n]+)", 0);
+    if (!endsWith_String(out, "\n")) {
+        appendCStr_String(out, "\n");
+    }
+    iForEach(Array, i, links) {
+        iPendingLink *pending = i.value;
+        const char *url = cstr_String(pending->url);
+        if (startsWith_CStr(url, "[]")) {
+            /* Find the matching named link. */
+            iRegExpMatch m;
+            init_RegExpMatch(&m);
+            while (matchString_RegExp(namePattern, source, &m)) {
+                if (equal_Rangecc(capturedRange_RegExpMatch(&m, 1), url + 2)) {
+                    url = cstrCollect_String(captured_RegExpMatch(&m, 2));
+                    break;
+                }
+            }
+        }
+        appendFormat_String(out, "\n=> %s %s", url, cstr_String(pending->title));
+        delete_String(pending->url);
+        delete_String(pending->title);
+    }
+    clear_Array(links);
+    iRelease(namePattern);
+}
+
+static void convertMarkdownToGemtext_GmDocument_(iGmDocument *d) {
+    iAssert(d->format == markdown_SourceFormat);
+    /* Get rid of indented preformats. */ {
+        iArray *pendingLinks = collectNew_Array(sizeof(iPendingLink));
+        const iRegExp *imageLinkPattern = iClob(new_RegExp("\n?!\\[(.+)\\]\\(([^)]+)\\)\n?", 0));
+        const iRegExp *linkPattern = iClob(new_RegExp("\\[(.+?)\\]\\(([^)]+)\\)", 0));
+        const iRegExp *namedLinkPattern = iClob(new_RegExp("\\[(.+?)\\]\\[(.+?)\\]", 0));
+        const iRegExp *namePattern = iClob(new_RegExp("\\s*\\[(.+?)\\]\\s*:\\s*([^\n]+)", 0));
+        iString result;
+        init_String(&result);
+        iRangecc line = iNullRange;
+        iBool isPre = iFalse;
+        iBool isLastEmpty = iFalse;
+        while (nextSplit_Rangecc(range_String(&d->source), "\n", &line)) {
+            if (!isPre) {
+                if (*line.start == '#') {
+                    flushPendingLinks_(pendingLinks, &d->source, &result);
+                }
+                if (isEmpty_Range(&line)) {
+                    isLastEmpty = iTrue;
+                    continue;
+                }
+                if (isLastEmpty) {
+                    appendCStr_String(&result, "\n\n");
+                }
+                else if (size_Range(&line) >= 2 && isnumber(line.start[0]) &&
+                         (line.start[1] == '.' ||
+                          (isnumber(line.start[1]) && line.start[2] == '.'))) {
+                    appendCStr_String(&result, "\n\n");
+                }
+                else if (*line.start == '*' || *line.start == '>' || *line.start == '#') {
+                    appendCStr_String(&result, "\n");
+                }
+                else {
+                    appendCStr_String(&result, " ");
+                }
+                isLastEmpty = iFalse;
+            }
+            if (startsWith_Rangecc(line, "    ")) {
+                line.start += 4;
+                if (!isPre) {
+                    appendCStr_String(&result, "```\n");
+                    isPre = iTrue;
+                }
+            }
+            else if (isPre) {
+                if (!endsWith_String(&result, "\n")) {
+                    appendCStr_String(&result, "\n");
+                }
+                appendCStr_String(&result, "```\n");
+                isPre = iFalse;
+            }
+            /* Check for image links. */
+            if (isPre) {
+                appendRange_String(&result, line);
+                appendCStr_String(&result, "\n");
+            }
+            else {
+                iString ln;
+                initRange_String(&ln, line);
+                replaceRegExp_String(&ln, iClob(new_RegExp("\\*\\*(.+?)\\*\\*", 0)), "\x1b[1m\\1\x1b[0m", NULL, NULL);
+                replaceRegExp_String(&ln, iClob(new_RegExp("\\b\\*(.+?)\\*\\b", 0)), "\x1b[3m\\1\x1b[0m", NULL, NULL);
+                replaceRegExp_String(&ln, iClob(new_RegExp("\\b_(.+?)_\\b", 0)), "\x1b[3m\\1\x1b[0m", NULL, NULL);
+                replaceRegExp_String(&ln, iClob(new_RegExp("```([^`]+?)```", 0)), "\n```\n\\1\n```\n", NULL, NULL);
+                replaceRegExp_String(&ln, namePattern, "", NULL, 0);
+                replaceRegExp_String(&ln, imageLinkPattern, "\n=> \\2 \\1\n", NULL, NULL);
+                replaceRegExp_String(&ln, namedLinkPattern, "\\1", addPendingNamedLink_, pendingLinks);
+                replaceRegExp_String(&ln, linkPattern, "\\1", addPendingLink_, pendingLinks);
+                replaceRegExp_String(&ln, iClob(new_RegExp("(?<!`)`([^`]*?)`(?!`)", 0)), "\x1b[4m\\1\x1b[0m", NULL, NULL);
+                append_String(&result, &ln);
+                deinit_String(&ln);
+            }
+        }
+        flushPendingLinks_(pendingLinks, &d->source, &result);
+        set_String(&d->source, &result);
+        deinit_String(&result);
+    }
+    /* Replace Markdown syntax with equivalent Gemtext, where possible. */
+//    replaceRegExp_String(&d->source, iClob(new_RegExp("```([^`]+)```", 0)), "\n\n```\v\\1\v```\n\n");
+//    replaceRegExp_String(&d->source, iClob(new_RegExp("\n\\s*([0-9]+)\\.", 0)), "\n\n\\1."); /* numbered list */
+    replaceRegExp_String(&d->source, iClob(new_RegExp("(\\s*\n){2,}", 0)), "\n\n", NULL, NULL); /* normalize paragraph breaks */
+    printf("Converted:\n%s", cstr_String(&d->source));
+//    replaceRegExp_String(&d->source, iClob(new_RegExp("\n(?![*>#]\\s)", 0)), " "); /* normal line breaks */
+//    replace_String(&d->source, "\f", "\n\n");
+//    replace_String(&d->source, "\v", "\n");
+    d->format = gemini_SourceFormat;
+}
+
 void setSource_GmDocument(iGmDocument *d, const iString *source, int width, int outsideMargin,
                           enum iGmDocumentUpdate updateType) {
+    /* TODO: This API has been set up to allow partial/progressive updating of the content.
+       Currently the entire source is replaced every time, though. */
 //    printf("[GmDocument] source update (%zu bytes), width:%d, final:%d\n",
 //           size_String(source), width, updateType == final_GmDocumentUpdate);
     if (size_String(source) == size_String(&d->unormSource)) {
@@ -1724,6 +1899,10 @@ void setSource_GmDocument(iGmDocument *d, const iString *source, int width, int
     set_String(&d->unormSource, source);
     /* Normalize. */
     set_String(&d->source, &d->unormSource);
+    if (d->format == markdown_SourceFormat) {
+        convertMarkdownToGemtext_GmDocument_(d);
+        set_String(&d->unormSource, &d->source);
+    }
     if (isNormalized_GmDocument_(d)) {
         normalize_GmDocument(d);
     }
diff --git a/src/gmutil.c b/src/gmutil.c
index 5be7e198..692c1cb9 100644
--- a/src/gmutil.c
+++ b/src/gmutil.c
@@ -566,6 +566,12 @@ const char *mediaTypeFromFileExtension_String(const iString *d) {
     else if (endsWithCase_String(d, ".mid")) {
         return "audio/midi";
     }
+    else if (endsWithCase_String(d, ".md") ||
+             endsWithCase_String(d, ".markdown") ||
+             endsWithCase_String(d, ".mdown") ||
+             endsWithCase_String(d, ".markdn")) {
+        return "text/markdown";
+    }
     else if (endsWithCase_String(d, ".txt") ||
              endsWithCase_String(d, ".ini") ||
              endsWithCase_String(d, ".md") ||
diff --git a/src/ui/documentwidget.c b/src/ui/documentwidget.c
index ee669c1a..8c87ba1a 100644
--- a/src/ui/documentwidget.c
+++ b/src/ui/documentwidget.c
@@ -1481,6 +1481,10 @@ static void updateDocument_DocumentWidget_(iDocumentWidget *d,
                     docFormat = gemini_SourceFormat;
                     setRange_String(&d->sourceMime, param);
                 }
+                else if (equal_Rangecc(param, "text/markdown")) {
+                    docFormat = markdown_SourceFormat;
+                    setRange_String(&d->sourceMime, param);
+                }
                 else if (startsWith_Rangecc(param, "text/") ||
                          equal_Rangecc(param, "application/json") ||
                          equal_Rangecc(param, "application/x-pem-file") ||
diff --git a/src/ui/text.c b/src/ui/text.c
index 3ed5b327..3d2cdf5d 100644
--- a/src/ui/text.c
+++ b/src/ui/text.c
@@ -914,6 +914,18 @@ static void finishRun_AttributedText_(iAttributedText *d, iAttributedRun *run, i
     run->logical.start = endAt;
 }
 
+static iFont *withStyle_Font_(const iFont *d, enum iFontStyle styleId) {
+    const int fontId = (fontId_Text_(d) / maxVariants_Fonts) * maxVariants_Fonts;
+    const int sizeId = sizeId_Text_(d);
+    return font_Text_(FONT_ID(fontId, styleId, sizeId));
+}
+
+static iFont *withFontId_Font_(const iFont *d, enum iFontId fontId) {
+    const int styleId = styleId_Text_(d);
+    const int sizeId = sizeId_Text_(d);
+    return font_Text_(FONT_ID(fontId, styleId, sizeId));
+}
+
 static void prepare_AttributedText_(iAttributedText *d, int overrideBaseDir, iChar overrideChar) {
     iAssert(isEmpty_Array(&d->runs));
     size_t length = 0;
@@ -976,6 +988,7 @@ static void prepare_AttributedText_(iAttributedText *d, int overrideBaseDir, iCh
     const iChar *  logicalText = constData_Array(&d->logical);
     iBool          isRTL       = d->isBaseRTL;
     int            numNonSpace = 0;
+    iFont *        activeFont  = d->font;
     for (int pos = 0; pos < length; pos++) {
         const iChar ch = logicalText[pos];
 #if defined (LAGRANGE_ENABLE_FRIBIDI)
@@ -1004,8 +1017,23 @@ static void prepare_AttributedText_(iAttributedText *d, int overrideBaseDir, iCh
             init_RegExpMatch(&m);
             if (match_RegExp(activeText_->ansiEscape, srcPos, d->source.end - srcPos, &m)) {
                 finishRun_AttributedText_(d, &run, pos - 1);
-                run.fgColor = ansiForeground_Color(capturedRange_RegExpMatch(&m, 1),
-                                                   tmParagraph_ColorId);
+                const iRangecc sequence = capturedRange_RegExpMatch(&m, 1);
+                if (equal_Rangecc(sequence, "1")) {
+                    activeFont = withStyle_Font_(activeFont, bold_FontStyle);
+                }
+                else if (equal_Rangecc(sequence, "3")) {
+                    activeFont = withStyle_Font_(activeFont, italic_FontStyle);
+                }
+                else if (equal_Rangecc(sequence, "4")) {
+                    activeFont = withFontId_Font_(activeFont, monospace_FontId);
+                }
+                else if (equal_Rangecc(sequence, "0")) {
+                    activeFont = d->font; /* restore original */
+                    run.fgColor = d->fgColor;
+                }
+                else {
+                    run.fgColor = ansiForeground_Color(sequence, tmParagraph_ColorId);
+                }
                 pos += length_Rangecc(capturedRange_RegExpMatch(&m, 0));
                 iAssert(logToSource[pos] == end_RegExpMatch(&m) - d->source.start);
                 /* The run continues after the escape sequence. */
@@ -1047,7 +1075,7 @@ static void prepare_AttributedText_(iAttributedText *d, int overrideBaseDir, iCh
             }
             continue;
         }
-        iFont *currentFont = d->font;
+        iFont *currentFont = activeFont;
         if (run.font->fontSpec->flags & arabic_FontSpecFlag && isPunct_Char(ch)) {
             currentFont = run.font; /* remain as Arabic for whitespace */
         }
@@ -1766,6 +1794,9 @@ static iRect run_Font_(iFont *d, const iRunArgs *args) {
                                  orig.y + yCursor - yOffset + glyph->font->baseline + glyph->d[hoff].y,
                                  glyph->rect[hoff].size.x,
                                  glyph->rect[hoff].size.y };
+                if (run->font->height < d->height) {
+                    dst.y += d->baseline - run->font->baseline;
+                }
                 if (mode & visualFlag_RunMode) {
                     if (isEmpty_Rect(bounds)) {
                         bounds = init_Rect(dst.x, dst.y, dst.w, dst.h);