apex-ruby 1.0.6 → 1.0.8

data/ext/apex_ext/apex_src/src/extensions/syntax_highlight.c

@@ -25,6 +25,8 @@ static const char *get_tool_binary(const char *tool) {
         return "pygmentize";
     } else if (strcmp(tool, "skylighting") == 0) {
         return "skylighting";
+    } else if (strcmp(tool, "shiki") == 0) {
+        return "shiki";
     }
     return NULL;
 }
@@ -189,10 +191,11 @@ static char *run_command(const char *cmd, const char *input) {
 
 /**
  * Highlight a single code block using the specified tool.
- * Returns newly allocated HTML, or NULL on failure.
+ * Returns newly allocated HTML (or ANSI when ansi_output is true), or NULL on failure.
  */
 static char *highlight_code_block(const char *code, const char *language,
-                                  const char *tool, bool line_numbers) {
+                                  const char *tool, bool line_numbers, bool ansi_output,
+                                  const char *theme) {
     char cmd[512];
     const char *binary = get_tool_binary(tool);
     if (!binary) return NULL;
@@ -200,15 +203,23 @@ static char *highlight_code_block(const char *code, const char *language,
     if (strcmp(tool, "pygments") == 0) {
         /* Pygments: pygmentize -l LANG -f html [-O linenos=1] */
         if (language && *language) {
-            if (line_numbers) {
+            if (line_numbers && theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s -l %s -f html -O linenos=1,style=%s", binary, language, theme);
+            } else if (line_numbers) {
                 snprintf(cmd, sizeof(cmd), "%s -l %s -f html -O linenos=1", binary, language);
+            } else if (theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s -l %s -f html -O style=%s", binary, language, theme);
             } else {
                 snprintf(cmd, sizeof(cmd), "%s -l %s -f html", binary, language);
             }
         } else {
             /* Use -g for auto-detection when no language specified */
-            if (line_numbers) {
+            if (line_numbers && theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s -g -f html -O linenos=1,style=%s", binary, theme);
+            } else if (line_numbers) {
                 snprintf(cmd, sizeof(cmd), "%s -g -f html -O linenos=1", binary);
+            } else if (theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s -g -f html -O style=%s", binary, theme);
             } else {
                 snprintf(cmd, sizeof(cmd), "%s -g -f html", binary);
             }
@@ -217,19 +228,52 @@ static char *highlight_code_block(const char *code, const char *language,
         /* Skylighting: skylighting --syntax LANG -f html -r [-n]
          * -r = fragment mode (no full HTML document wrapper) */
         if (language && *language) {
-            if (line_numbers) {
-                snprintf(cmd, sizeof(cmd), "%s --syntax %s -f html -r -n", binary, language);
+            if (line_numbers && theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s --syntax %s --style %s -f html -r -n",
+                         binary, language, theme);
+            } else if (line_numbers) {
+                snprintf(cmd, sizeof(cmd), "%s --syntax %s -f html -r -n",
+                         binary, language);
+            } else if (theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s --syntax %s --style %s -f html -r",
+                         binary, language, theme);
             } else {
-                snprintf(cmd, sizeof(cmd), "%s --syntax %s -f html -r", binary, language);
+                snprintf(cmd, sizeof(cmd), "%s --syntax %s -f html -r",
+                         binary, language);
             }
         } else {
             /* Skylighting without syntax tries to auto-detect, but may fail */
-            if (line_numbers) {
+            if (line_numbers && theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s --style %s -f html -r -n",
+                         binary, theme);
+            } else if (line_numbers) {
                 snprintf(cmd, sizeof(cmd), "%s -f html -r -n", binary);
+            } else if (theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s --style %s -f html -r",
+                         binary, theme);
             } else {
                 snprintf(cmd, sizeof(cmd), "%s -f html -r", binary);
             }
         }
+    } else if (strcmp(tool, "shiki") == 0) {
+        /* Shiki CLI: shiki [--lang LANG] --format html|ansi
+         * Reads code from stdin. Exits non-zero if lang is missing and cannot be auto-detected;
+         * we capture that and fall back to plain text. */
+        const char *fmt = ansi_output ? "ansi" : "html";
+        if (language && *language) {
+            if (theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s --lang %s --theme %s --format %s", binary, language, theme, fmt);
+            } else {
+                snprintf(cmd, sizeof(cmd), "%s --lang %s --format %s", binary, language, fmt);
+            }
+        } else {
+            /* No language: Shiki may fail (non-zero exit); run_command returns NULL → we use original block */
+            if (theme && *theme) {
+                snprintf(cmd, sizeof(cmd), "%s --theme %s --format %s", binary, theme, fmt);
+            } else {
+                snprintf(cmd, sizeof(cmd), "%s --format %s", binary, fmt);
+            }
+        }
     } else {
         return NULL;
     }
@@ -240,7 +284,8 @@ static char *highlight_code_block(const char *code, const char *language,
 /**
  * Apply syntax highlighting to code blocks in HTML.
  */
-char *apex_apply_syntax_highlighting(const char *html, const char *tool, bool line_numbers, bool language_only) {
+char *apex_apply_syntax_highlighting(const char *html, const char *tool, bool line_numbers,
+                                     bool language_only, bool ansi_output, const char *theme) {
     if (!html || !tool) return html ? strdup(html) : NULL;
 
     /* Check if tool is available */
@@ -399,7 +444,7 @@ char *apex_apply_syntax_highlighting(const char *html, const char *tool, bool li
             }
 
             /* Run syntax highlighter */
-            char *highlighted = highlight_code_block(code, language, tool, line_numbers);
+            char *highlighted = highlight_code_block(code, language, tool, line_numbers, ansi_output, theme);
             free(code);
 
             if (highlighted && *highlighted) {

data/ext/apex_ext/apex_src/src/extensions/syntax_highlight.h

@@ -22,21 +22,24 @@
  * Supported tools:
  * - "pygments": Uses pygmentize command (Python)
  * - "skylighting": Uses skylighting command (Haskell)
+ * - "shiki": Uses shiki CLI (@shikijs/cli); uses --format html or ansi based on ansi_output
  *
  * @param html The HTML output containing code blocks to highlight
- * @param tool The highlighting tool name ("pygments" or "skylighting")
+ * @param tool The highlighting tool name ("pygments", "skylighting", or "shiki")
  * @param line_numbers Whether to include line numbers in output
  * @param language_only When true, only highlight blocks that have a language specified
+ * @param ansi_output When true, request ANSI output (e.g. for terminal); only affects Shiki (--format ansi vs html)
+ * @param theme Optional theme/style name to pass to the external tool (e.g. Pygments style, Shiki theme)
  * @return Newly allocated HTML with highlighted code blocks, or NULL on error.
  *         If the tool is not found or fails, returns a copy of the original HTML
- *         with a warning printed to stderr.
+ *         with a warning printed to stderr. For Shiki, non-zero exit (e.g. missing --lang) yields plain text.
  */
-char *apex_apply_syntax_highlighting(const char *html, const char *tool, bool line_numbers, bool language_only);
+char *apex_apply_syntax_highlighting(const char *html, const char *tool, bool line_numbers, bool language_only, bool ansi_output, const char *theme);
 
 /**
  * Check if a syntax highlighting tool is available in PATH.
  *
- * @param tool The tool name ("pygments" or "skylighting")
+ * @param tool The tool name ("pygments", "skylighting", or "shiki")
  * @return true if the tool's binary is found and executable, false otherwise
  */
 bool apex_syntax_highlighter_available(const char *tool);

data/ext/apex_ext/apex_src/src/extensions/table_html_postprocess.c

@@ -305,6 +305,47 @@ static bool process_cell_alignment(const char **content_start, const char **cont
     return false;
 }
 
+/**
+ * Extract [Caption] text from a paragraph node.
+ * Handles both: (1) TEXT node with literal "[Caption]", (2) LINK node where [text] was parsed as link.
+ * Returns allocated string or NULL. Caller must free.
+ */
+static char *get_caption_from_paragraph(cmark_node *para) {
+    if (!para || cmark_node_get_type(para) != CMARK_NODE_PARAGRAPH) return NULL;
+    cmark_node *child = cmark_node_first_child(para);
+    if (!child) return NULL;
+
+    cmark_node_type t = cmark_node_get_type(child);
+    if (t == CMARK_NODE_TEXT) {
+        const char *text = cmark_node_get_literal(child);
+        if (!text || text[0] != '[') return NULL;
+        const char *end = strchr(text + 1, ']');
+        if (!end) return NULL;
+        const char *after = end + 1;
+        while (*after && isspace((unsigned char)*after)) after++;
+        if (*after != '\0') return NULL;
+        size_t len = (size_t)(end - text - 1);
+        if (len == 0 || len >= 512) return NULL;
+        char *caption = malloc(len + 1);
+        if (caption) {
+            memcpy(caption, text + 1, len);
+            caption[len] = '\0';
+        }
+        return caption;
+    }
+    if (t == CMARK_NODE_LINK) {
+        /* [Caption] parsed as link - caption is the link text */
+        cmark_node *link_text = cmark_node_first_child(child);
+        if (!link_text || cmark_node_get_type(link_text) != CMARK_NODE_TEXT) return NULL;
+        const char *text = cmark_node_get_literal(link_text);
+        if (!text) return NULL;
+        /* Only treat as caption if it's the only content (no siblings) */
+        if (cmark_node_next(link_text) != NULL) return NULL;
+        return strdup(text);
+    }
+    return NULL;
+}
+
 /**
  * Get text fingerprint from paragraph node (first 50 chars for matching)
  */
@@ -386,35 +427,30 @@ static table_caption *collect_table_captions(cmark_node *document, para_to_remov
                     /* Check previous node for caption */
                     cmark_node *prev = cmark_node_previous(node);
                     if (prev && cmark_node_get_type(prev) == CMARK_NODE_PARAGRAPH) {
-                        /* Check if previous paragraph is a caption */
-                        cmark_node *text_node = cmark_node_first_child(prev);
-                        if (text_node && cmark_node_get_type(text_node) == CMARK_NODE_TEXT) {
-                            const char *text = cmark_node_get_literal(text_node);
-                            if (text && text[0] == '[') {
-                                const char *end = strchr(text + 1, ']');
-                                if (end) {
-                                    const char *after = end + 1;
-                                    while (*after && isspace((unsigned char)*after)) after++;
-                                    if (*after == '\0') {
-                                        /* This is a caption - extract it */
-                                        size_t caption_len = end - text - 1;
-                                        char *caption = malloc(caption_len + 1);
-                                        if (caption) {
-                                            memcpy(caption, text + 1, caption_len);
-                                            caption[caption_len] = '\0';
-                                            table_caption *cap = malloc(sizeof(table_caption));
-                                            if (cap) {
-                                                cap->table_index = table_index;
-                                                cap->caption = caption;
-                                                cap->next = list;
-                                                list = cap;
-                                                caption_found = true;
-                                            } else {
-                                                free(caption);
-                                            }
-                                        }
+                        char *caption = get_caption_from_paragraph(prev);
+                        if (caption) {
+                            table_caption *cap = malloc(sizeof(table_caption));
+                            if (cap) {
+                                cap->table_index = table_index;
+                                cap->caption = caption;
+                                cap->next = list;
+                                list = cap;
+                                caption_found = true;
+                                /* Mark caption paragraph for removal (para_index is prev's index) */
+                                char *fingerprint = get_para_text_fingerprint(prev);
+                                if (fingerprint) {
+                                    para_to_remove *para = malloc(sizeof(para_to_remove));
+                                    if (para) {
+                                        para->para_index = para_index;
+                                        para->text_fingerprint = fingerprint;
+                                        para->next = *paras_to_remove;
+                                        *paras_to_remove = para;
+                                    } else {
+                                        free(fingerprint);
                                     }
                                 }
+                            } else {
+                                free(caption);
                             }
                         }
                     }
@@ -422,33 +458,29 @@ static table_caption *collect_table_captions(cmark_node *document, para_to_remov
                     if (!caption_found) {
                         cmark_node *next = cmark_node_next(node);
                         if (next && cmark_node_get_type(next) == CMARK_NODE_PARAGRAPH) {
-                            cmark_node *text_node = cmark_node_first_child(next);
-                            if (text_node && cmark_node_get_type(text_node) == CMARK_NODE_TEXT) {
-                                const char *text = cmark_node_get_literal(text_node);
-                                if (text && text[0] == '[') {
-                                    const char *end = strchr(text + 1, ']');
-                                    if (end) {
-                                        const char *after = end + 1;
-                                        while (*after && isspace((unsigned char)*after)) after++;
-                                        if (*after == '\0') {
-                                            /* This is a caption - extract it */
-                                            size_t caption_len = end - text - 1;
-                                            char *caption = malloc(caption_len + 1);
-                                            if (caption) {
-                                                memcpy(caption, text + 1, caption_len);
-                                                caption[caption_len] = '\0';
-                                                table_caption *cap = malloc(sizeof(table_caption));
-                                                if (cap) {
-                                                    cap->table_index = table_index;
-                                                    cap->caption = caption;
-                                                    cap->next = list;
-                                                    list = cap;
-                                                } else {
-                                                    free(caption);
-                                                }
-                                            }
+                            char *caption = get_caption_from_paragraph(next);
+                            if (caption) {
+                                table_caption *cap = malloc(sizeof(table_caption));
+                                if (cap) {
+                                    cap->table_index = table_index;
+                                    cap->caption = caption;
+                                    cap->next = list;
+                                    list = cap;
+                                    /* Mark caption paragraph for removal (next's index = para_index + 1) */
+                                    char *fingerprint = get_para_text_fingerprint(next);
+                                    if (fingerprint) {
+                                        para_to_remove *para = malloc(sizeof(para_to_remove));
+                                        if (para) {
+                                            para->para_index = para_index + 1;
+                                            para->text_fingerprint = fingerprint;
+                                            para->next = *paras_to_remove;
+                                            *paras_to_remove = para;
+                                        } else {
+                                            free(fingerprint);
                                         }
                                     }
+                                } else {
+                                    free(caption);
                                 }
                             }
                         }

data/ext/apex_ext/apex_src/src/extensions/toc.c

@@ -79,6 +79,7 @@ static header_item *collect_headers(cmark_node *node, header_item **tail) {
 
 /**
  * Generate TOC HTML from headers
+ * Produces valid ul > li > ul nesting (nested lists inside list items)
  */
 static char *generate_toc_html(header_item *headers, int min_level, int max_level) {
     if (!headers) return strdup("");
@@ -90,6 +91,7 @@ static char *generate_toc_html(header_item *headers, int min_level, int max_leve
     char *write = html;
     size_t remaining = capacity;
     int current_level = 0;
+    int last_level = 0;  /* level of last item added (0 = none yet) */
 
     #define APPEND(str) do { \
         size_t len = strlen(str); \
@@ -106,28 +108,46 @@ static char *generate_toc_html(header_item *headers, int min_level, int max_leve
         /* Skip headers outside min/max range */
         if (h->level < min_level || h->level > max_level) continue;
 
-        /* Close lists if going up levels */
+        /* Going up: close </ul></li> for each level (nested ul inside parent li) */
         while (current_level > h->level) {
-            APPEND("</ul>\n");
+            APPEND("</ul>\n</li>\n");
             current_level--;
         }
 
-        /* Open lists if going down levels */
+        /* Going down: open one <ul> inside the previous li before adding child.
+         * At root (current_level 0): only open one ul - never ul > ul.
+         * When going deeper: open exactly one ul per step - never ul > ul. */
         while (current_level < h->level) {
-            APPEND("<ul>\n");
-            current_level++;
+            if (current_level == 0) {
+                APPEND("<ul>\n");
+                current_level = 1;
+                break;
+            }
+            if (last_level > 0) {
+                APPEND("<ul>\n");
+                current_level++;
+                break;
+            } else {
+                break;  /* No parent li - add as direct child of root ul */
+            }
+        }
+
+        /* Close previous li when adding sibling (same or shallower level) */
+        if (last_level > 0 && h->level <= last_level) {
+            APPEND("</li>\n");
         }
 
-        /* Add list item */
+        /* Add list item (leave open - may contain nested ul) */
         char item[1024];
-        snprintf(item, sizeof(item), "<li><a href=\"#%s\">%s</a></li>\n",
+        snprintf(item, sizeof(item), "<li><a href=\"#%s\">%s</a>",
                  h->id, h->text);
         APPEND(item);
+        last_level = h->level;
     }
 
-    /* Close remaining lists */
+    /* Close remaining: </li></ul> for each open level */
     while (current_level > 0) {
-        APPEND("</ul>\n");
+        APPEND("</li>\n</ul>\n");
         current_level--;
     }
 
@@ -139,6 +159,62 @@ static char *generate_toc_html(header_item *headers, int min_level, int max_leve
     return html;
 }
 
+/**
+ * Return true if position 'pos' in 'html' is inside a <code> or <pre> element.
+ * Used to skip TOC markers that appear in code blocks or inline code.
+ */
+static int is_inside_code_or_pre(const char *html, size_t pos) {
+    int in_code = 0;
+    int in_pre = 0;
+    size_t i = 0;
+    size_t len = pos;
+
+    while (i < len) {
+        if (html[i] == '<') {
+            if (i + 5 <= len && (html[i+1] == 'c' || html[i+1] == 'C') &&
+                (html[i+2] == 'o' || html[i+2] == 'O') &&
+                (html[i+3] == 'd' || html[i+3] == 'D') &&
+                (html[i+4] == 'e' || html[i+4] == 'E')) {
+                char next = (i + 5 < len) ? html[i + 5] : '\0';
+                if (next == '>' || next == ' ' || next == '\t' || next == '\n') {
+                    in_code++;
+                    i += 5;
+                    continue;
+                }
+            }
+            if (i + 4 <= len && (html[i+1] == 'p' || html[i+1] == 'P') &&
+                (html[i+2] == 'r' || html[i+2] == 'R') &&
+                (html[i+3] == 'e' || html[i+3] == 'E')) {
+                char next = (i + 4 < len) ? html[i + 4] : '\0';
+                if (next == '>' || next == ' ' || next == '\t' || next == '\n') {
+                    in_pre++;
+                    i += 4;
+                    continue;
+                }
+            }
+            if (i + 7 <= len && html[i+1] == '/' &&
+                (html[i+2] == 'c' || html[i+2] == 'C') &&
+                (html[i+3] == 'o' || html[i+3] == 'O') &&
+                (html[i+4] == 'd' || html[i+4] == 'D') &&
+                (html[i+5] == 'e' || html[i+5] == 'E') && html[i+6] == '>') {
+                if (in_code > 0) in_code--;
+                i += 7;
+                continue;
+            }
+            if (i + 6 <= len && html[i+1] == '/' &&
+                (html[i+2] == 'p' || html[i+2] == 'P') &&
+                (html[i+3] == 'r' || html[i+3] == 'R') &&
+                (html[i+4] == 'e' || html[i+4] == 'E') && html[i+5] == '>') {
+                if (in_pre > 0) in_pre--;
+                i += 6;
+                continue;
+            }
+        }
+        i++;
+    }
+    return (in_code > 0 || in_pre > 0);
+}
+
 /**
  * Parse TOC marker for min/max levels
  */
@@ -180,18 +256,57 @@ static void parse_toc_marker(const char *marker, int *min_level, int *max_level)
     }
 }
 
+/**
+ * Find the first TOC marker (<!--TOC or {{TOC) that is not inside <code> or <pre>.
+ * Returns pointer to the marker, or NULL if none valid. *is_html_comment is set
+ * to 1 for <!--TOC, 0 for {{TOC.
+ */
+static const char *find_toc_marker_not_in_code(const char *html, int *is_html_comment) {
+    const char *p = html;
+    *is_html_comment = 0;
+
+    while (1) {
+        const char *next_comment = strstr(p, "<!--TOC");
+        const char *next_mmd = strstr(p, "{{TOC");
+
+        /* No more markers */
+        if (!next_comment && !next_mmd) return NULL;
+
+        /* Pick the earlier of the two */
+        const char *cand = NULL;
+        if (next_comment && next_mmd) {
+            cand = (next_comment < next_mmd) ? next_comment : next_mmd;
+        } else {
+            cand = next_comment ? next_comment : next_mmd;
+        }
+
+        if (!is_inside_code_or_pre(html, (size_t)(cand - html))) {
+            *is_html_comment = (cand == next_comment);
+            return cand;
+        }
+
+        /* This occurrence is inside code; skip past it and search again */
+        if (cand == next_comment) {
+            const char *end = strstr(cand, "-->");
+            p = end ? end + 3 : cand + 1;
+        } else {
+            const char *end = strstr(cand, "}}");
+            p = end ? end + 2 : cand + 1;
+        }
+    }
+}
+
 /**
  * Process TOC markers in HTML
  */
 char *apex_process_toc(const char *html, cmark_node *document, int id_format) {
     if (!html || !document) return html ? strdup(html) : NULL;
 
-    /* Check if there are any TOC markers */
-    const char *toc_marker = strstr(html, "<!--TOC");
-    const char *toc_mmd = strstr(html, "{{TOC");
+    int is_html_comment = 0;
+    const char *marker = find_toc_marker_not_in_code(html, &is_html_comment);
 
-    if (!toc_marker && !toc_mmd) {
-        return strdup(html);  /* No TOC markers, return as-is */
+    if (!marker) {
+        return strdup(html);  /* No valid TOC marker (or all are in code), return as-is */
     }
 
     /* Collect headers from document */
@@ -204,8 +319,7 @@ char *apex_process_toc(const char *html, cmark_node *document, int id_format) {
         h->id = apex_generate_header_id(h->text, (apex_id_format_t)id_format);
     }
 
-    /* Find the marker and parse it */
-    const char *marker = toc_marker ? toc_marker : toc_mmd;
+    /* Parse the marker for min/max levels */
     int min_level, max_level;
     parse_toc_marker(marker, &min_level, &max_level);
 
@@ -227,10 +341,10 @@ char *apex_process_toc(const char *html, cmark_node *document, int id_format) {
 
     /* Find end of marker */
     const char *marker_end = NULL;
-    if (toc_marker) {
+    if (is_html_comment) {
         marker_end = strstr(marker, "-->");
         if (marker_end) marker_end += 3;
-    } else if (toc_mmd) {
+    } else {
         marker_end = strstr(marker, "}}");
         if (marker_end) marker_end += 2;
     }
@@ -242,7 +356,7 @@ char *apex_process_toc(const char *html, cmark_node *document, int id_format) {
     }
 
     /* Build output: before + TOC + after */
-    size_t before_len = marker - html;
+    size_t before_len = (size_t)(marker - html);
     size_t after_len = strlen(marker_end);
 
     memcpy(output, html, before_len);