apex-ruby 1.0.6 → 1.0.8

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

@@ -1,10 +1,8 @@
 /**
- * Definition List Extension for Apex
+ * One-Line Definition List Extension for Apex
  *
- * Supports Kramdown/PHP Markdown Extra style definition lists:
- * Term
- * : Definition 1
- * : Definition 2
+ * Supports: Term :: Definition text  or  Term::Definition text
+ * Multiple consecutive lines create one <dl> with multiple <dt>/<dd> pairs.
  */
 
 #ifndef APEX_DEFINITION_LIST_H
@@ -12,31 +10,26 @@
 
 #include <stdbool.h>
 #include "cmark-gfm.h"
-#include "cmark-gfm-extension_api.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/* Custom node types for definition lists */
-/* Note: APEX_NODE_DEFINITION_* are defined as enum values in parser.h, not as variables */
-
 /**
- * Process definition lists via preprocessing
- * Converts : syntax to HTML before main parsing
+ * Process one-line definition lists via preprocessing.
+ * Converts "Term :: Definition" lines to <dl><dt>Term</dt><dd>Definition</dd></dl>
  * @param text The markdown text to process
- * @param unsafe If true, allow raw HTML in output (pass CMARK_OPT_UNSAFE)
+ * @param unsafe If true, allow raw HTML in output
  */
 char *apex_process_definition_lists(const char *text, bool unsafe);
 
 /**
- * Create and return the definition list extension
+ * Debug touch - no-op for one-line format
  */
-cmark_syntax_extension *create_definition_list_extension(void);
+void apex_deflist_debug_touch(int enable_definition_lists);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* APEX_DEFINITION_LIST_H */
-

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

@@ -7,6 +7,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include "emoji_data.h"
 
@@ -15,6 +16,30 @@ static void normalize_emoji_name(char *name);
 static int is_table_alignment_pattern(const char *start, const char *end);
 static int is_inside_html_attribute(const char *pos, const char *start);
 
+/** True if content at p looks like a list marker (- , * , + , or digit+. ) */
+static int looks_like_list_marker(const char *p) {
+    if (!*p) return 0;
+    if (*p == '-' || *p == '*' || *p == '+')
+        return (p[1] == ' ' || p[1] == '\t');
+    if (isdigit((unsigned char)*p)) {
+        while (isdigit((unsigned char)*p)) p++;
+        return (*p == '.' && (p[1] == ' ' || p[1] == '\t'));
+    }
+    return 0;
+}
+
+/** True if we're at the start of a line that is an indented code block (4+ spaces or tab). */
+static int line_is_indented_code_block(const char *read) {
+    if (!*read) return 0;
+    if (*read == '\t')
+        return !looks_like_list_marker(read + 1);
+    if (read[0] != ' ' || read[1] != ' ' || read[2] != ' ' || read[3] != ' ')
+        return 0;
+    const char *content = read + 4;
+    while (*content == ' ') content++;
+    return *content && !looks_like_list_marker(content);
+}
+
 /**
  * Find emoji entry by name
  * Returns pointer to emoji_entry or NULL if not found
@@ -234,7 +259,33 @@ char *apex_replace_emoji(const char *html) {
     char *write = output;
     size_t remaining = capacity;
 
+    bool in_code_tag = false;  /* Skip emoji inside <code>...</code> and <pre>...</pre> */
+
     while (*read) {
+        /* Track <code> and <pre> tags - skip emoji replacement inside code */
+        if (*read == '<' && read[1]) {
+            if (read[6] && read[1] == '/' && read[2] == 'c' && read[3] == 'o' && read[4] == 'd' && read[5] == 'e' && read[6] == '>') {
+                in_code_tag = false;
+            } else if (read[5] && read[1] == '/' && read[2] == 'p' && read[3] == 'r' && read[4] == 'e' && read[5] == '>') {
+                in_code_tag = false;
+            } else if (read[5] && read[1] == 'c' && read[2] == 'o' && read[3] == 'd' && read[4] == 'e' &&
+                       (read[5] == '>' || read[5] == ' ' || read[5] == '\t')) {
+                in_code_tag = true;
+            } else if (read[4] && read[1] == 'p' && read[2] == 'r' && read[3] == 'e' &&
+                       (read[4] == '>' || read[4] == ' ' || read[4] == '\t')) {
+                in_code_tag = true;
+            }
+        }
+        if (in_code_tag) {
+            if (remaining > 0) {
+                *write++ = *read++;
+                remaining--;
+            } else {
+                read++;
+            }
+            continue;
+        }
+
         /* Check if we're inside an index placeholder <!--IDX:...--> - if so, skip emoji processing */
         if (read >= html + 7 && strncmp(read - 7, "<!--IDX:", 8) == 0) {
             /* Find the end of the placeholder */
@@ -437,6 +488,133 @@ char *apex_replace_emoji(const char *html) {
     return output;
 }
 
+/**
+ * Replace :emoji: patterns in plain text with Unicode emoji only.
+ *
+ * This variant is intended for non-HTML outputs (e.g. terminal rendering)
+ * where we do not want to emit <img> tags. It reuses the same emoji table
+ * but only substitutes entries that have a Unicode representation; image-
+ * only emoji names are left as their original :name: patterns.
+ */
+char *apex_replace_emoji_text(const char *text) {
+    if (!text) return NULL;
+
+    size_t capacity = strlen(text) * 2 + 16;  /* Enough for most unicode expansions */
+    char *output = malloc(capacity);
+    if (!output) return strdup(text);
+
+    const char *read = text;
+    char *write = output;
+    size_t remaining = capacity;
+
+    bool in_code_block = false;
+    bool in_inline_code = false;
+    bool in_indented_code_block = false;
+
+    while (*read) {
+        /* At line start: indented code block only if 4+ spaces/tab and not a list line */
+        if (read == text || read[-1] == '\n') {
+            in_indented_code_block = line_is_indented_code_block(read);
+        }
+
+        /* Track fenced code blocks (```) and inline code (`) */
+        if (*read == '`') {
+            if (read[1] == '`' && read[2] == '`') {
+                in_code_block = !in_code_block;
+            } else if (!in_code_block) {
+                in_inline_code = !in_inline_code;
+            }
+        }
+
+        /* Skip emoji replacement inside any code context */
+        if (in_code_block || in_inline_code || in_indented_code_block) {
+            if (remaining > 0) {
+                *write++ = *read++;
+                remaining--;
+            } else {
+                read++;
+            }
+            continue;
+        }
+
+        if (*read == ':') {
+            /* Look for closing : */
+            const char *end = strchr(read + 1, ':');
+            if (end && (end - read) < 50) {  /* Reasonable emoji name length */
+                /* Extract emoji name */
+                int name_len = (int)(end - (read + 1));
+                const char *name_start = read + 1;
+
+                if (name_len > 0) {
+                    /* Reject names containing whitespace */
+                    int has_space = 0;
+                    for (int i = 0; i < name_len; i++) {
+                        char ch = name_start[i];
+                        if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') {
+                            has_space = 1;
+                            break;
+                        }
+                    }
+
+                    /* Skip common table alignment patterns like :---: */
+                    if (!has_space && is_table_alignment_pattern(name_start, end)) {
+                        size_t pattern_len = (size_t)(end - read + 1);
+                        if (pattern_len <= remaining) {
+                            memcpy(write, read, pattern_len);
+                            write += pattern_len;
+                            remaining -= pattern_len;
+                        }
+                        read = end + 1;
+                        continue;
+                    }
+
+                    if (!has_space) {
+                        /* Normalize name and look up in emoji table */
+                        char normalized[64];
+                        if ((size_t)name_len >= sizeof(normalized)) {
+                            name_len = (int)sizeof(normalized) - 1;
+                        }
+                        memcpy(normalized, name_start, (size_t)name_len);
+                        normalized[name_len] = '\0';
+                        normalize_emoji_name(normalized);
+                        size_t normalized_len = strlen(normalized);
+
+                        const emoji_entry *entry = find_emoji_entry(normalized, (int)normalized_len);
+                        if (entry && entry->unicode) {
+                            /* Substitute Unicode emoji */
+                            size_t emoji_len = strlen(entry->unicode);
+                            if (emoji_len <= remaining) {
+                                memcpy(write, entry->unicode, emoji_len);
+                                write += emoji_len;
+                                remaining -= emoji_len;
+                                read = end + 1;
+                                continue;
+                            }
+                            /* If not enough space, fall through and copy pattern as-is */
+                        }
+                    }
+                }
+            }
+        }
+
+        /* Default: copy single byte */
+        if (remaining > 0) {
+            *write++ = *read++;
+            remaining--;
+        } else {
+            read++;
+        }
+    }
+
+    if (remaining > 0) {
+        *write = '\0';
+    } else {
+        output[capacity - 1] = '\0';
+    }
+
+    return output;
+}
+
 /**
  * Normalize emoji name: lowercase, hyphens to underscores, remove colons
  */
@@ -584,7 +762,36 @@ char *apex_autocorrect_emoji_names(const char *text) {
     char *write = output;
     size_t remaining = capacity;
 
+    bool in_code_block = false;
+    bool in_inline_code = false;
+    bool in_indented_code_block = false;
+
     while (*read) {
+        /* At line start: indented code block only if 4+ spaces/tab and not a list line */
+        if (read == text || read[-1] == '\n') {
+            in_indented_code_block = line_is_indented_code_block(read);
+        }
+
+        /* Track fenced code blocks (```) and inline code (`) */
+        if (*read == '`') {
+            if (read[1] == '`' && read[2] == '`') {
+                in_code_block = !in_code_block;
+            } else if (!in_code_block) {
+                in_inline_code = !in_inline_code;
+            }
+        }
+
+        /* Skip emoji processing inside any code context */
+        if (in_code_block || in_inline_code || in_indented_code_block) {
+            if (remaining > 0) {
+                *write++ = *read++;
+                remaining--;
+            } else {
+                read++;
+            }
+            continue;
+        }
+
         if (*read == ':') {
             /* Look for closing : */
             const char *end = strchr(read + 1, ':');

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

@@ -14,6 +14,20 @@ extern "C" {
  */
 char *apex_replace_emoji(const char *html);
 
+/**
+ * Replace :emoji: patterns in plain text with Unicode emoji only.
+ *
+ * This is suitable for non-HTML outputs (e.g. terminal rendering) where
+ * image-based emoji tags are not desired. If an emoji entry has no
+ * Unicode representation (image-only), the original :emoji: pattern is
+ * left unchanged.
+ *
+ * @param text Plain text to process (UTF-8)
+ * @return Newly allocated string with emoji replacements applied, or NULL
+ *         on error. Caller must free the returned string.
+ */
+char *apex_replace_emoji_text(const char *text);
+
 /**
  * Find emoji name from unicode emoji (reverse lookup)
  * @param unicode The unicode emoji string (UTF-8)

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

@@ -98,6 +98,15 @@ char *apex_generate_header_id(const char *text, apex_id_format_t format) {
             continue;
         }
 
+        /* Check for apostrophes: curly (') U+2019: 0xE2 0x80 0x99, left quote (') U+2018: 0xE2 0x80 0x98 */
+        if (c == 0xE2 && read[1] != '\0' && read[2] != '\0' &&
+            (unsigned char)read[1] == 0x80 &&
+            ((unsigned char)read[2] == 0x99 || (unsigned char)read[2] == 0x98)) {
+            /* Remove apostrophes in all formats - they break anchor links */
+            read += 2;
+            continue;
+        }
+
         if (format == APEX_ID_FORMAT_MMD) {
             /* MMD format: preserve dashes, lowercase alphanumerics, preserve diacritics, skip spaces/punctuation */
             if (c == '-') {
@@ -381,6 +390,51 @@ char *apex_generate_header_id(const char *text, apex_id_format_t format) {
     return id;
 }
 
+/**
+ * Recursively append literal text from node and its descendants to buffer.
+ * Handles TEXT, CODE, and recurses into inline containers (EMPH, STRONG, etc.)
+ * so "### *Processing* modes" yields "Processing modes" matching rendered HTML.
+ */
+static void append_literal(char **text, char **write, size_t *capacity, size_t *remaining,
+                          const char *literal) {
+    if (!literal) return;
+    size_t len = strlen(literal);
+    while (len >= *remaining) {
+        size_t new_cap = *capacity * 2;
+        char *new_text = realloc(*text, new_cap);
+        if (!new_text) return;
+        *write = new_text + (*write - *text);
+        *text = new_text;
+        *capacity = new_cap;
+        *remaining = new_cap - (size_t)(*write - *text);
+    }
+    memcpy(*write, literal, len);
+    *write += len;
+    *remaining -= len;
+}
+
+static void extract_heading_text_recursive(cmark_node *node, char **text, char **write,
+                                           size_t *capacity, size_t *remaining) {
+    cmark_node_type type = cmark_node_get_type(node);
+
+    if (type == CMARK_NODE_TEXT || type == CMARK_NODE_CODE) {
+        append_literal(text, write, capacity, remaining, cmark_node_get_literal(node));
+        return;
+    }
+    /* HTML_INLINE has literal (e.g. "&") - needed for "Documentation & resources" */
+    if (type == CMARK_NODE_HTML_INLINE) {
+        append_literal(text, write, capacity, remaining, cmark_node_get_literal(node));
+        return;
+    }
+
+    /* Recurse into inline containers (EMPH, STRONG, LINK, etc.) */
+    cmark_node *child = cmark_node_first_child(node);
+    while (child) {
+        extract_heading_text_recursive(child, text, write, capacity, remaining);
+        child = cmark_node_next(child);
+    }
+}
+
 /**
  * Extract text content from a heading node
  */
@@ -389,59 +443,15 @@ char *apex_extract_heading_text(cmark_node *heading_node) {
         return strdup("");
     }
 
-    /* Walk children and collect text */
     size_t capacity = 256;
     char *text = malloc(capacity);
     if (!text) return strdup("");
-
     char *write = text;
     size_t remaining = capacity;
 
     cmark_node *child = cmark_node_first_child(heading_node);
     while (child) {
-        cmark_node_type type = cmark_node_get_type(child);
-
-        if (type == CMARK_NODE_TEXT) {
-            const char *literal = cmark_node_get_literal(child);
-            if (literal) {
-                size_t len = strlen(literal);
-                if (len >= remaining) {
-                    size_t new_capacity = capacity * 2;
-                    char *new_text = realloc(text, new_capacity);
-                    if (!new_text) {
-                        free(text);
-                        return strdup("");
-                    }
-                    write = new_text + (write - text);
-                    text = new_text;
-                    remaining = new_capacity - (write - text);
-                }
-                memcpy(write, literal, len);
-                write += len;
-                remaining -= len;
-            }
-        } else if (type == CMARK_NODE_CODE) {
-            const char *literal = cmark_node_get_literal(child);
-            if (literal) {
-                size_t len = strlen(literal);
-                if (len >= remaining) {
-                    size_t new_capacity = capacity * 2;
-                    char *new_text = realloc(text, new_capacity);
-                    if (!new_text) {
-                        free(text);
-                        return strdup("");
-                    }
-                    write = new_text + (write - text);
-                    text = new_text;
-                    remaining = new_capacity - (write - text);
-                }
-                memcpy(write, literal, len);
-                write += len;
-                remaining -= len;
-            }
-        }
-        /* Skip other inline elements for ID generation */
-
+        extract_heading_text_recursive(child, &text, &write, &capacity, &remaining);
         child = cmark_node_next(child);
     }
 
@@ -562,43 +572,91 @@ bool apex_extract_manual_header_id(char **heading_text, char **manual_id_out) {
     return false;
 }
 
+/**
+ * Extract plain text from a link node (for simple [ref] style).
+ * Returns allocated string or NULL.
+ */
+static char *get_link_label_text(cmark_node *link_node) {
+    if (!link_node || cmark_node_get_type(link_node) != CMARK_NODE_LINK) return NULL;
+    cmark_node *child = cmark_node_first_child(link_node);
+    if (!child || cmark_node_get_type(child) != CMARK_NODE_TEXT) return NULL;
+    const char *literal = cmark_node_get_literal(child);
+    return literal ? strdup(literal) : NULL;
+}
+
+/**
+ * Check if a string is a valid MMD heading ID (no spaces, no metadata %).
+ */
+static bool is_valid_mmd_id(const char *s) {
+    if (!s || !*s) return false;
+    for (; *s; s++) {
+        if (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\r' || *s == '%') return false;
+    }
+    return true;
+}
+
 /**
  * Process manual header IDs in a heading node
  * Extracts MMD [id] or Kramdown {#id} syntax and stores ID in user_data
  * Updates the heading text node to remove the manual ID syntax
+ *
+ * Walks ALL text children (not just first) so headings split by "&" etc.
+ * (e.g. TEXT + HTML_INLINE + TEXT) are handled - the IAL may be in a later child.
+ *
+ * Edge case: When [id] matches a link reference and would render as a link,
+ * but [id] is the last element in the heading with other content before it,
+ * treat it as MMD heading ID (not a link). This avoids the conflict where
+ * "# Heading [mermaid]" with "[mermaid]: URL" would wrongly render mermaid as
+ * a link. If the heading is ONLY [id] (e.g. "# [mermaid]"), keep it as a link
+ * to avoid empty headings.
  */
 bool apex_process_manual_header_id(cmark_node *heading_node) {
     if (!heading_node || cmark_node_get_type(heading_node) != CMARK_NODE_HEADING) {
         return false;
     }
 
-    /* Get the text node inside the heading */
-    cmark_node *text_node = cmark_node_first_child(heading_node);
-    if (!text_node || cmark_node_get_type(text_node) != CMARK_NODE_TEXT) {
-        return false;
-    }
+    /* Check each TEXT child for manual ID - "&" etc. can split content across nodes.
+       Prefer the rightmost (last) match to align with IAL behavior. */
+    cmark_node *match_node = NULL;
+    char *match_text = NULL;
+    char *match_id = NULL;
 
-    const char *text = cmark_node_get_literal(text_node);
-    if (!text) return false;
+    for (cmark_node *child = cmark_node_first_child(heading_node); child;
+         child = cmark_node_next(child)) {
+        if (cmark_node_get_type(child) != CMARK_NODE_TEXT) continue;
 
-    /* Extract text and try to find manual ID */
-    char *text_copy = strdup(text);
-    if (!text_copy) return false;
+        const char *literal = cmark_node_get_literal(child);
+        if (!literal) continue;
 
-    char *manual_id = NULL;
-    bool found = apex_extract_manual_header_id(&text_copy, &manual_id);
+        char *text_copy = strdup(literal);
+        if (!text_copy) continue;
 
-    if (found && manual_id) {
+        char *manual_id = NULL;
+        bool found = apex_extract_manual_header_id(&text_copy, &manual_id);
+
+        if (found && manual_id) {
+            /* Discard previous match - we want the rightmost */
+            free(match_text);
+            free(match_id);
+            match_node = child;
+            match_text = text_copy;
+            match_id = manual_id;
+        } else {
+            free(text_copy);
+            if (manual_id) free(manual_id);
+        }
+    }
+
+    if (match_node && match_id) {
         /* Store ID in user_data as id="..." */
-        char *id_attr = malloc(strlen(manual_id) + 6);  /* id="" + null */
+        char *id_attr = malloc(strlen(match_id) + 6);  /* id="" + null */
         if (id_attr) {
-            sprintf(id_attr, "id=\"%s\"", manual_id);
+            sprintf(id_attr, "id=\"%s\"", match_id);
 
-            /* Merge with existing user_data if present */
+            /* Merge with existing user_data if present (e.g. from IAL) */
             char *existing = (char *)cmark_node_get_user_data(heading_node);
             if (existing) {
-                /* Append to existing */
-                char *combined = malloc(strlen(existing) + strlen(id_attr) + 2);  /* + space + null */
+                char *combined = malloc(strlen(existing) + strlen(id_attr) + 2);
                 if (combined) {
                     sprintf(combined, "%s %s", existing, id_attr);
                     cmark_node_set_user_data(heading_node, combined);
@@ -611,16 +669,65 @@ bool apex_process_manual_header_id(cmark_node *heading_node) {
             }
         }
 
-        /* Update the text node to remove manual ID syntax */
-        cmark_node_set_literal(text_node, text_copy);
-
-        free(manual_id);
-        free(text_copy);
+        cmark_node_set_literal(match_node, match_text);
+        free(match_id);
+        free(match_text);
         return true;
     }
 
-    free(text_copy);
-    if (manual_id) free(manual_id);
-    return false;
+    /* Edge case: [id] was parsed as a link (ref existed). If it's the last
+     * element and there's other content, treat as MMD heading ID. */
+    cmark_node *last = NULL;
+    cmark_node *child = cmark_node_first_child(heading_node);
+    while (child) {
+        cmark_node_type t = cmark_node_get_type(child);
+        if (t != CMARK_NODE_SOFTBREAK && t != CMARK_NODE_LINEBREAK) {
+            last = child;
+        }
+        child = cmark_node_next(child);
+    }
+
+    if (!last || cmark_node_get_type(last) != CMARK_NODE_LINK) return false;
+
+    /* Must have at least one sibling before the link (avoid empty headings) */
+    cmark_node *prev = cmark_node_previous(last);
+    if (!prev) return false;
+
+    char *link_text = get_link_label_text(last);
+    if (!link_text || !is_valid_mmd_id(link_text)) {
+        free(link_text);
+        return false;
+    }
+
+    /* Replace link with text node, set heading id */
+    cmark_node *text_replacement = cmark_node_new(CMARK_NODE_TEXT);
+    if (!text_replacement) {
+        free(link_text);
+        return false;
+    }
+    cmark_node_set_literal(text_replacement, link_text);
+    cmark_node_insert_before(last, text_replacement);
+    cmark_node_unlink(last);
+    cmark_node_free(last);
+
+    char *id_attr = malloc(strlen(link_text) + 6);
+    if (id_attr) {
+        sprintf(id_attr, "id=\"%s\"", link_text);
+        char *existing = (char *)cmark_node_get_user_data(heading_node);
+        if (existing) {
+            char *combined = malloc(strlen(existing) + strlen(id_attr) + 2);
+            if (combined) {
+                sprintf(combined, "%s %s", existing, id_attr);
+                cmark_node_set_user_data(heading_node, combined);
+                free(id_attr);
+            } else {
+                cmark_node_set_user_data(heading_node, id_attr);
+            }
+        } else {
+            cmark_node_set_user_data(heading_node, id_attr);
+        }
+    }
+    free(link_text);
+    return true;
 }