apex-ruby 1.0.18 → 1.0.20

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

@@ -5,10 +5,210 @@
 
 #include "toc.h"
 #include "header_ids.h"
+#include "apex/apex.h"
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
+#include <stdbool.h>
+
+/* Placeholders for backslash-escaped {{TOC...}} markers preserved through parsing. */
+static char **escaped_toc_originals = NULL;
+static size_t escaped_toc_count = 0;
+
+static void clear_escaped_toc_store(void) {
+    if (escaped_toc_originals) {
+        for (size_t i = 0; i < escaped_toc_count; i++) {
+            free(escaped_toc_originals[i]);
+        }
+        free(escaped_toc_originals);
+    }
+    escaped_toc_originals = NULL;
+    escaped_toc_count = 0;
+}
+
+static bool is_escaped_mmd_toc_start(const char *p) {
+    return p[0] == '\\' && p[1] == '{' && p[2] == '\\' && p[3] == '{' &&
+           strncmp(p + 4, "TOC", 3) == 0;
+}
+
+static const char *find_escaped_mmd_toc_end(const char *start) {
+    const char *p = start + 7;
+    while (*p) {
+        if (p[0] == '\\' && p[1] == '}' && p[2] == '\\' && p[3] == '}') {
+            return p + 3;
+        }
+        p++;
+    }
+    return NULL;
+}
+
+static char *build_unescaped_toc_marker(const char *escaped_start, const char *escaped_end) {
+    /* \{\{ ... \}\} -> {{ ... }} */
+    const char *inner = escaped_start + 4;
+    size_t inner_len = (size_t)(escaped_end - inner - 3);
+    size_t out_len = inner_len + 4;
+    char *out = malloc(out_len + 1);
+    if (!out) return NULL;
+    out[0] = '{';
+    out[1] = '{';
+    memcpy(out + 2, inner, inner_len);
+    out[2 + inner_len] = '}';
+    out[3 + inner_len] = '}';
+    out[out_len] = '\0';
+    return out;
+}
+
+char *apex_protect_escaped_toc_markers(const char *text) {
+    if (!text) return NULL;
+
+    clear_escaped_toc_store();
+
+    size_t len = strlen(text);
+    size_t capacity = len + 64;
+    char *output = malloc(capacity);
+    if (!output) return NULL;
+
+    const char *read = text;
+    char *write = output;
+    size_t remaining = capacity;
+
+    while (*read) {
+        if (is_escaped_mmd_toc_start(read)) {
+            const char *end = find_escaped_mmd_toc_end(read);
+            if (end) {
+                char *original = build_unescaped_toc_marker(read, end);
+                if (!original) {
+                    free(output);
+                    clear_escaped_toc_store();
+                    return NULL;
+                }
+
+                char **new_store = realloc(escaped_toc_originals,
+                                           (escaped_toc_count + 1) * sizeof(char *));
+                if (!new_store) {
+                    free(original);
+                    free(output);
+                    clear_escaped_toc_store();
+                    return NULL;
+                }
+                escaped_toc_originals = new_store;
+                escaped_toc_originals[escaped_toc_count++] = original;
+
+                char placeholder[64];
+                int ph_len = snprintf(placeholder, sizeof(placeholder),
+                                      "@APEX_ESCAPED_TOC_%zu@", escaped_toc_count - 1);
+                if ((size_t)ph_len >= remaining) {
+                    size_t written = (size_t)(write - output);
+                    capacity = written + (size_t)ph_len + len + 64;
+                    char *new_output = realloc(output, capacity);
+                    if (!new_output) {
+                        free(output);
+                        clear_escaped_toc_store();
+                        return NULL;
+                    }
+                    output = new_output;
+                    write = output + written;
+                    remaining = capacity - written;
+                }
+                memcpy(write, placeholder, (size_t)ph_len);
+                write += ph_len;
+                remaining -= (size_t)ph_len;
+                read = end + 1;
+                continue;
+            }
+        }
+
+        if (remaining == 0) {
+            size_t written = (size_t)(write - output);
+            capacity = (written + len + 64) * 2;
+            char *new_output = realloc(output, capacity);
+            if (!new_output) {
+                free(output);
+                clear_escaped_toc_store();
+                return NULL;
+            }
+            output = new_output;
+            write = output + written;
+            remaining = capacity - written;
+        }
+        *write++ = *read++;
+        remaining--;
+    }
+
+    *write = '\0';
+    return output;
+}
+
+char *apex_restore_escaped_toc_markers(const char *html) {
+    if (!html) return NULL;
+    if (escaped_toc_count == 0) return strdup(html);
+
+    size_t len = strlen(html);
+    size_t capacity = len + escaped_toc_count * 32;
+    char *output = malloc(capacity);
+    if (!output) return NULL;
+
+    const char *read = html;
+    char *write = output;
+    size_t remaining = capacity;
+
+    while (*read) {
+        if (strncmp(read, "@APEX_ESCAPED_TOC_", 18) == 0) {
+            const char *idx_start = read + 18;
+            const char *idx_end = strchr(idx_start, '@');
+            if (idx_end && idx_end > idx_start) {
+                char idx_buf[32];
+                size_t idx_len = (size_t)(idx_end - idx_start);
+                if (idx_len < sizeof(idx_buf)) {
+                    memcpy(idx_buf, idx_start, idx_len);
+                    idx_buf[idx_len] = '\0';
+                    size_t index = (size_t)atoi(idx_buf);
+                    if (index < escaped_toc_count && escaped_toc_originals[index]) {
+                        const char *original = escaped_toc_originals[index];
+                        size_t orig_len = strlen(original);
+                        if (orig_len >= remaining) {
+                            size_t written = (size_t)(write - output);
+                            capacity = written + orig_len + 64;
+                            char *new_output = realloc(output, capacity);
+                            if (!new_output) {
+                                free(output);
+                                return NULL;
+                            }
+                            output = new_output;
+                            write = output + written;
+                            remaining = capacity - written;
+                        }
+                        memcpy(write, original, orig_len);
+                        write += orig_len;
+                        remaining -= orig_len;
+                        read = idx_end + 1;
+                        continue;
+                    }
+                }
+            }
+        }
+
+        if (remaining == 0) {
+            size_t written = (size_t)(write - output);
+            capacity = (written + len + 64) * 2;
+            char *new_output = realloc(output, capacity);
+            if (!new_output) {
+                free(output);
+                return NULL;
+            }
+            output = new_output;
+            write = output + written;
+            remaining = capacity - written;
+        }
+        *write++ = *read++;
+        remaining--;
+    }
+
+    *write = '\0';
+    clear_escaped_toc_store();
+    return output;
+}
 
 /**
  * Collect headers from AST
@@ -20,6 +220,61 @@ typedef struct header_item {
     struct header_item *next;
 } header_item;
 
+/* Normalize heading text for TOC labels:
+ * - trim leading/trailing whitespace
+ * - collapse internal whitespace runs to a single space
+ */
+static char *normalize_toc_text(const char *text) {
+    if (!text) return strdup("");
+
+    size_t len = strlen(text);
+    char *out = malloc(len + 1);
+    if (!out) return strdup("");
+
+    const unsigned char *read = (const unsigned char *)text;
+    while (*read && isspace(*read)) read++;
+
+    char *write = out;
+    int pending_space = 0;
+
+    while (*read) {
+        if (isspace(*read)) {
+            pending_space = 1;
+        } else {
+            if (pending_space && write > out) {
+                *write++ = ' ';
+            }
+            *write++ = (char)*read;
+            pending_space = 0;
+        }
+        read++;
+    }
+
+    *write = '\0';
+    return out;
+}
+
+static char *heading_id_from_attrs_or_text(const char *attrs, const char *text,
+                                           apex_id_format_t id_format) {
+    if (attrs) {
+        const char *id_attr = strstr(attrs, "id=\"");
+        if (id_attr) {
+            const char *id_start = id_attr + 4;
+            const char *id_end = strchr(id_start, '"');
+            if (id_end && id_end > id_start) {
+                size_t id_len = (size_t)(id_end - id_start);
+                char *id = malloc(id_len + 1);
+                if (id) {
+                    memcpy(id, id_start, id_len);
+                    id[id_len] = '\0';
+                    return id;
+                }
+            }
+        }
+    }
+    return apex_generate_header_id(text, id_format);
+}
+
 static void free_headers(header_item *headers) {
     while (headers) {
         header_item *next = headers->next;
@@ -30,12 +285,42 @@ static void free_headers(header_item *headers) {
     }
 }
 
+static void clamp_toc_levels(int *min_level, int *max_level) {
+    if (*min_level < 1) *min_level = 1;
+    if (*max_level < 1) *max_level = 1;
+    if (*min_level > 6) *min_level = 6;
+    if (*max_level > 6) *max_level = 6;
+    if (*min_level > *max_level) *min_level = *max_level;
+}
+
+static bool append_toc_markdown(char **buffer, size_t *capacity, size_t *length,
+                                const char *text, size_t text_len) {
+    if (!buffer || !*buffer || !capacity || !length) return false;
+
+    if (*length + text_len + 1 > *capacity) {
+        size_t new_capacity = *capacity;
+        while (*length + text_len + 1 > new_capacity) {
+            new_capacity *= 2;
+        }
+        char *new_buffer = realloc(*buffer, new_capacity);
+        if (!new_buffer) return false;
+        *buffer = new_buffer;
+        *capacity = new_capacity;
+    }
+
+    memcpy(*buffer + *length, text, text_len);
+    *length += text_len;
+    (*buffer)[*length] = '\0';
+    return true;
+}
+
 
 
 /**
  * Collect all headers from document
  */
-static header_item *collect_headers(cmark_node *node, header_item **tail) {
+static header_item *collect_headers(cmark_node *node, header_item **tail,
+                                    apex_id_format_t id_format) {
     if (!node) return NULL;
 
     header_item *headers = NULL;
@@ -54,8 +339,10 @@ static header_item *collect_headers(cmark_node *node, header_item **tail) {
             header_item *item = malloc(sizeof(header_item));
             if (item) {
                 item->level = cmark_node_get_heading_level(node);
-                item->text = apex_extract_heading_text(node);
-                item->id = NULL;  /* Will be set later with format */
+                char *raw_text = apex_extract_heading_text(node);
+                item->text = normalize_toc_text(raw_text);
+                free(raw_text);
+                item->id = heading_id_from_attrs_or_text(attrs, item->text, id_format);
                 item->next = NULL;
 
                 if (*tail) {
@@ -70,7 +357,7 @@ static header_item *collect_headers(cmark_node *node, header_item **tail) {
 
     /* Recursively process children */
     for (cmark_node *child = cmark_node_first_child(node); child; child = cmark_node_next(child)) {
-        header_item *child_headers = collect_headers(child, tail);
+        header_item *child_headers = collect_headers(child, tail, id_format);
         if (!headers) headers = child_headers;
     }
 
@@ -91,7 +378,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) */
+    int last_level = 0;  /* normalized level of last item added (0 = none yet) */
 
     #define APPEND(str) do { \
         size_t len = strlen(str); \
@@ -107,9 +394,11 @@ static char *generate_toc_html(header_item *headers, int min_level, int max_leve
     for (header_item *h = headers; h; h = h->next) {
         /* Skip headers outside min/max range */
         if (h->level < min_level || h->level > max_level) continue;
+        int target_level = h->level - min_level + 1;
+        if (target_level < 1) target_level = 1;
 
         /* Going up: close </ul></li> for each level (nested ul inside parent li) */
-        while (current_level > h->level) {
+        while (current_level > target_level) {
             APPEND("</ul>\n</li>\n");
             current_level--;
         }
@@ -117,7 +406,7 @@ static char *generate_toc_html(header_item *headers, int min_level, int max_leve
         /* 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) {
+        while (current_level < target_level) {
             if (current_level == 0) {
                 APPEND("<ul>\n");
                 current_level = 1;
@@ -133,7 +422,7 @@ static char *generate_toc_html(header_item *headers, int min_level, int max_leve
         }
 
         /* Close previous li when adding sibling (same or shallower level) */
-        if (last_level > 0 && h->level <= last_level) {
+        if (last_level > 0 && target_level <= last_level) {
             APPEND("</li>\n");
         }
 
@@ -142,7 +431,7 @@ static char *generate_toc_html(header_item *headers, int min_level, int max_leve
         snprintf(item, sizeof(item), "<li><a href=\"#%s\">%s</a>",
                  h->id, h->text);
         APPEND(item);
-        last_level = h->level;
+        last_level = target_level;
     }
 
     /* Close remaining: </li></ul> for each open level */
@@ -159,6 +448,108 @@ static char *generate_toc_html(header_item *headers, int min_level, int max_leve
     return html;
 }
 
+void apex_toc_entries_free(apex_toc_entry *entries, size_t count) {
+    if (!entries) return;
+    for (size_t i = 0; i < count; i++) {
+        free(entries[i].text);
+        free(entries[i].id);
+    }
+    free(entries);
+}
+
+apex_toc_entry *apex_generate_toc_entries(cmark_node *document, int id_format,
+                                          int min_level, int max_level,
+                                          size_t *out_count) {
+    if (out_count) *out_count = 0;
+    if (!document || !out_count) return NULL;
+
+    clamp_toc_levels(&min_level, &max_level);
+
+    header_item *tail = NULL;
+    header_item *headers = collect_headers(document, &tail, (apex_id_format_t)id_format);
+    if (!headers) return NULL;
+
+    size_t count = 0;
+    for (header_item *h = headers; h; h = h->next) {
+        if (h->level >= min_level && h->level <= max_level) count++;
+    }
+
+    if (count == 0) {
+        free_headers(headers);
+        return NULL;
+    }
+
+    apex_toc_entry *entries = calloc(count, sizeof(apex_toc_entry));
+    if (!entries) {
+        free_headers(headers);
+        return NULL;
+    }
+
+    size_t idx = 0;
+    for (header_item *h = headers; h; h = h->next) {
+        if (h->level < min_level || h->level > max_level) continue;
+        entries[idx].level = h->level;
+        entries[idx].text = h->text ? strdup(h->text) : strdup("");
+        entries[idx].id = h->id ? strdup(h->id) : strdup("");
+        if (!entries[idx].text || !entries[idx].id) {
+            apex_toc_entries_free(entries, idx + 1);
+            free_headers(headers);
+            return NULL;
+        }
+        idx++;
+    }
+
+    free_headers(headers);
+    *out_count = count;
+    return entries;
+}
+
+char *apex_generate_toc_markdown(cmark_node *document, int id_format,
+                                 int min_level, int max_level) {
+    size_t count = 0;
+    apex_toc_entry *entries = apex_generate_toc_entries(document, id_format,
+                                                        min_level, max_level,
+                                                        &count);
+    if (!entries || count == 0) {
+        apex_toc_entries_free(entries, count);
+        return strdup("");
+    }
+
+    size_t capacity = 1024;
+    size_t length = 0;
+    char *markdown = malloc(capacity);
+    if (!markdown) {
+        apex_toc_entries_free(entries, count);
+        return strdup("");
+    }
+    markdown[0] = '\0';
+
+    clamp_toc_levels(&min_level, &max_level);
+
+    for (size_t i = 0; i < count; i++) {
+        int indent = (entries[i].level - min_level) * 2;
+        for (int j = 0; j < indent; j++) {
+            if (!append_toc_markdown(&markdown, &capacity, &length, " ", 1)) goto fail;
+        }
+
+        const char *text = entries[i].text ? entries[i].text : "";
+        const char *id = entries[i].id ? entries[i].id : "";
+        if (!append_toc_markdown(&markdown, &capacity, &length, "- [", 3)) goto fail;
+        if (!append_toc_markdown(&markdown, &capacity, &length, text, strlen(text))) goto fail;
+        if (!append_toc_markdown(&markdown, &capacity, &length, "](#", 3)) goto fail;
+        if (!append_toc_markdown(&markdown, &capacity, &length, id, strlen(id))) goto fail;
+        if (!append_toc_markdown(&markdown, &capacity, &length, ")\n", 2)) goto fail;
+    }
+
+    apex_toc_entries_free(entries, count);
+    return markdown;
+
+fail:
+    free(markdown);
+    apex_toc_entries_free(entries, count);
+    return strdup("");
+}
+
 /**
  * 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.
@@ -218,42 +609,76 @@ static int is_inside_code_or_pre(const char *html, size_t pos) {
 /**
  * Parse TOC marker for min/max levels
  */
-static void parse_toc_marker(const char *marker, int *min_level, int *max_level) {
-    *min_level = 1;
-    *max_level = 6;
+static void parse_toc_marker(const char *marker, int *min_level, int *max_level,
+                             int default_min, int default_max) {
+    int specified_min = 0;
+    int specified_max = 0;
+
+    *min_level = default_min;
+    *max_level = default_max;
+
+    if (!marker) return;
+
+    /* Only parse inside the marker, never beyond marker end into following HTML. */
+    const char *marker_end = strstr(marker, "}}");
+    if (!marker_end) marker_end = strstr(marker, "-->");
+    if (!marker_end) {
+        marker_end = marker + strlen(marker);
+    }
+    size_t marker_len = (size_t)(marker_end - marker);
+    char *marker_copy = (char *)malloc(marker_len + 1);
+    if (!marker_copy) return;
+    memcpy(marker_copy, marker, marker_len);
+    marker_copy[marker_len] = '\0';
 
     /* Look for max and min parameters */
-    const char *max_str = strstr(marker, "max");
-    const char *min_str = strstr(marker, "min");
+    const char *max_str = strstr(marker_copy, "max");
+    const char *min_str = strstr(marker_copy, "min");
 
     if (max_str) {
         max_str += 3;
         while (*max_str && !isdigit((unsigned char)*max_str)) max_str++;
-        if (*max_str) *max_level = atoi(max_str);
+        if (*max_str) {
+            *max_level = atoi(max_str);
+            specified_max = 1;
+        }
     }
 
     if (min_str) {
         min_str += 3;
         while (*min_str && !isdigit((unsigned char)*min_str)) min_str++;
-        if (*min_str) *min_level = atoi(min_str);
+        if (*min_str) {
+            *min_level = atoi(min_str);
+            specified_min = 1;
+        }
     }
 
     /* Check for Pandoc style {{TOC:2-5}} */
-    const char *colon = strchr(marker, ':');
+    const char *colon = strchr(marker_copy, ':');
     if (colon) {
         colon++;
         while (*colon && isspace((unsigned char)*colon)) colon++;
         if (isdigit((unsigned char)*colon)) {
             *min_level = atoi(colon);
+            specified_min = 1;
             const char *dash = strchr(colon, '-');
             if (dash) {
                 dash++;
                 if (isdigit((unsigned char)*dash)) {
                     *max_level = atoi(dash);
+                    specified_max = 1;
                 }
             }
         }
     }
+    free(marker_copy);
+
+    if (specified_min || specified_max) {
+        if (!specified_min) *min_level = 1;
+        if (!specified_max) *max_level = 6;
+    }
+
+    clamp_toc_levels(min_level, max_level);
 }
 
 /**
@@ -299,7 +724,8 @@ static const char *find_toc_marker_not_in_code(const char *html, int *is_html_co
 /**
  * Process TOC markers in HTML
  */
-char *apex_process_toc(const char *html, cmark_node *document, int id_format) {
+char *apex_process_toc(const char *html, cmark_node *document, int id_format,
+                       int default_min, int default_max) {
     if (!html || !document) return html ? strdup(html) : NULL;
 
     int is_html_comment = 0;
@@ -311,17 +737,12 @@ char *apex_process_toc(const char *html, cmark_node *document, int id_format) {
 
     /* Collect headers from document */
     header_item *tail = NULL;
-    header_item *headers = collect_headers(document, &tail);
+    header_item *headers = collect_headers(document, &tail, (apex_id_format_t)id_format);
     if (!headers) return strdup(html);
 
-    /* Generate IDs for all headers using the specified format */
-    for (header_item *h = headers; h; h = h->next) {
-        h->id = apex_generate_header_id(h->text, (apex_id_format_t)id_format);
-    }
-
     /* Parse the marker for min/max levels */
     int min_level, max_level;
-    parse_toc_marker(marker, &min_level, &max_level);
+    parse_toc_marker(marker, &min_level, &max_level, default_min, default_max);
 
     /* Generate TOC HTML */
     char *toc_html = generate_toc_html(headers, min_level, max_level);

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

@@ -23,8 +23,33 @@ extern "C" {
  * @param html The HTML output
  * @param document The AST document
  * @param id_format 0=GFM (with dashes), 1=MMD (no dashes)
+ * @param default_min Default minimum heading level for bare TOC markers
+ * @param default_max Default maximum heading level for bare TOC markers
  */
-char *apex_process_toc(const char *html, cmark_node *document, int id_format);
+char *apex_process_toc(const char *html, cmark_node *document, int id_format,
+                       int default_min, int default_max);
+
+/**
+ * Generate a Markdown table of contents from document headings.
+ * Returns a newly allocated string containing "- [text](#id)" entries.
+ * @param document The AST document
+ * @param id_format 0=GFM (with dashes), 1=MMD (no dashes)
+ * @param min_level Inclusive minimum heading level
+ * @param max_level Inclusive maximum heading level
+ */
+char *apex_generate_toc_markdown(cmark_node *document, int id_format,
+                                 int min_level, int max_level);
+
+/**
+ * Replace backslash-escaped {{TOC...}} markers with placeholders before parsing.
+ * Call before markdown parse when TOC processing will run later.
+ */
+char *apex_protect_escaped_toc_markers(const char *text);
+
+/**
+ * Restore placeholders to literal {{TOC...}} text in HTML after TOC processing.
+ */
+char *apex_restore_escaped_toc_markers(const char *html);
 
 #ifdef __cplusplus
 }

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

@@ -332,6 +332,11 @@ static cmark_node *match_wiki_link(cmark_syntax_extension *self,
     const char *input = (const char *)chunk->data + pos;
     int remaining = chunk->len - pos;
 
+    /* Do not parse Obsidian embeds ![[...]] as regular wiki links. */
+    if (pos > 0 && chunk->data[pos - 1] == '!') {
+        return NULL;
+    }
+
     /* CRITICAL: Must check for [[ to distinguish from regular markdown links [text](url) */
     if (remaining < 2 || input[0] != '[' || input[1] != '[') {
         return NULL;  /* Not a wiki link, let standard link parser handle it */
@@ -501,6 +506,29 @@ void apex_process_wiki_links_in_tree(cmark_node *node, wiki_link_config *config)
 
             size_t content_len = (size_t)(close - (open + 2));
 
+            /* Preserve Obsidian embeds ![[...]] as literal text so include
+             * preprocessing can handle them, and avoid rendering !<a ...>. */
+            if (open > literal && open[-1] == '!') {
+                size_t raw_len = (size_t)((close + 2) - open);
+                char *raw = malloc(raw_len + 1);
+                if (raw) {
+                    memcpy(raw, open, raw_len);
+                    raw[raw_len] = '\0';
+                    cmark_node *text = cmark_node_new(CMARK_NODE_TEXT);
+                    cmark_node_set_literal(text, raw);
+                    free(raw);
+                    if (!insert_after) {
+                        cmark_node_insert_before(node, text);
+                    } else {
+                        cmark_node_insert_after(insert_after, text);
+                    }
+                    insert_after = text;
+                    changed = true;
+                }
+                cursor = close + 2;
+                continue;
+            }
+
             /* If empty content, keep literal text and continue */
             if (content_len == 0) {
                 size_t raw_len = (size_t)((close + 2) - open);