apex-ruby 1.0.17 → 1.0.20

data/ext/apex_ext/apex_src/src/html_renderer.c

@@ -275,6 +275,67 @@ static char *extract_data_apex_picture_srcset(const char *attrs, const char *for
     return out;
 }
 
+/**
+ * Return attrs with internal data-apex-* and core img attrs removed.
+ * Keeps user-specified attrs (e.g. width/height/loading/class/style) for img fallback.
+ * Caller must free.
+ */
+static char *filter_img_fallback_attrs(const char *attrs) {
+    if (!attrs) return NULL;
+
+    size_t cap = strlen(attrs) + 1;
+    char *out = malloc(cap);
+    if (!out) return NULL;
+
+    char *w = out;
+    const char *p = attrs;
+
+    while (*p) {
+        while (*p && isspace((unsigned char)*p)) p++;
+        if (!*p) break;
+
+        const char *token_start = p;
+        const char *name_start = p;
+        while (*p && !isspace((unsigned char)*p) && *p != '=') p++;
+        const char *name_end = p;
+
+        if (*p == '=') {
+            p++; /* consume '=' */
+            if (*p == '"' || *p == '\'') {
+                char q = *p++;
+                while (*p && *p != q) p++;
+                if (*p == q) p++;
+            } else {
+                while (*p && !isspace((unsigned char)*p)) p++;
+            }
+        }
+
+        const char *token_end = p;
+        size_t name_len = (size_t)(name_end - name_start);
+        bool skip_attr = false;
+
+        if (name_len == 0) continue;
+
+        if (name_len >= 10 && strncasecmp(name_start, "data-apex-", 10) == 0) {
+            skip_attr = true;
+        } else if ((name_len == 3 && strncasecmp(name_start, "src", 3) == 0) ||
+                   (name_len == 3 && strncasecmp(name_start, "alt", 3) == 0) ||
+                   (name_len == 5 && strncasecmp(name_start, "title", 5) == 0)) {
+            skip_attr = true;
+        }
+
+        if (!skip_attr) {
+            if (w != out) *w++ = ' ';
+            size_t token_len = (size_t)(token_end - token_start);
+            memcpy(w, token_start, token_len);
+            w += token_len;
+        }
+    }
+
+    *w = '\0';
+    return out;
+}
+
 /* Counters for element indexing */
 typedef struct {
     int para_count;
@@ -335,16 +396,36 @@ static char *get_node_text_fingerprint(cmark_node *node) {
         }
     }
 
-    /* For links, use the URL */
+    /* For links, use URL + link text (first text child) to disambiguate
+     * same-href links and avoid matching raw HTML <a> tags. */
     if (type == CMARK_NODE_LINK) {
         const char *url = cmark_node_get_url(node);
         if (url) {
-            size_t len = strlen(url);
-            if (len > 50) len = 50;
-            char *fingerprint = malloc(len + 1);
+            size_t url_len = strlen(url);
+            if (url_len > 50) url_len = 50;
+            const char *text = NULL;
+            for (cmark_node *child = cmark_node_first_child(node); child;
+                 child = cmark_node_next(child)) {
+                if (cmark_node_get_type(child) == CMARK_NODE_TEXT) {
+                    text = cmark_node_get_literal(child);
+                    if (text && *text) break;
+                    text = NULL;
+                }
+            }
+            size_t text_len = text ? strlen(text) : 0;
+            if (text_len > 20) text_len = 20;
+            size_t total = url_len + (text_len ? 1 + text_len : 0);
+            if (total > 50) total = 50;
+            char *fingerprint = malloc(total + 1);
             if (fingerprint) {
-                memcpy(fingerprint, url, len);
-                fingerprint[len] = '\0';
+                memcpy(fingerprint, url, url_len);
+                size_t pos = url_len;
+                if (text_len && pos + 1 + text_len <= 50) {
+                    fingerprint[pos++] = '|';
+                    memcpy(fingerprint + pos, text, text_len);
+                    pos += text_len;
+                }
+                fingerprint[pos] = '\0';
                 return fingerprint;
             }
         }
@@ -661,6 +742,23 @@ char *apex_render_html_with_attributes(cmark_node *document, int options) {
                                         }
                                     }
                                 }
+                            } else if (elem_type == CMARK_NODE_LINK && fp_idx < 49) {
+                                /* Append visible text before any nested tag (skip image-only links). */
+                                const char *content_start = tag_end;
+                                if (*content_start == '>') content_start++;
+                                if (*content_start && *content_start != '<') {
+                                    size_t text_len = 0;
+                                    while (content_start[text_len] &&
+                                           content_start[text_len] != '<' &&
+                                           text_len < 20) {
+                                        text_len++;
+                                    }
+                                    if (text_len > 0 && fp_idx + 1 + text_len <= 50) {
+                                        html_fingerprint[fp_idx++] = '|';
+                                        memcpy(html_fingerprint + fp_idx, content_start, text_len);
+                                        fp_idx += text_len;
+                                    }
+                                }
                             }
                             html_fingerprint[fp_idx] = '\0';
                         }
@@ -714,6 +812,35 @@ char *apex_render_html_with_attributes(cmark_node *document, int options) {
                             break;
                         }
                     }
+                } else if (elem_type == CMARK_NODE_LINK) {
+                    /* Links: match by href(+text) fingerprint among unused attrs.
+                     * Raw HTML <a> tags inflate html link_count, so element_index is
+                     * not reliable. Consume matching fingerprints in document order. */
+                    if (fp_idx > 0) {
+                        for (attr_node *a = attr_list; a; a = a->next, idx++) {
+                            if (used[idx]) continue;
+                            if (a->node_type != CMARK_NODE_LINK) continue;
+                            if (!a->text_fingerprint) continue;
+                            if (strncmp(a->text_fingerprint, html_fingerprint, 50) == 0) {
+                                matching = a;
+                                used[idx] = true;
+                                break;
+                            }
+                        }
+                    }
+                    /* Fall back to index only when no fingerprint is available. */
+                    if (!matching) {
+                        idx = 0;
+                        for (attr_node *a = attr_list; a; a = a->next, idx++) {
+                            if (used[idx]) continue;
+                            if (a->node_type != CMARK_NODE_LINK) continue;
+                            if (!a->text_fingerprint && a->element_index == elem_idx) {
+                                matching = a;
+                                used[idx] = true;
+                                break;
+                            }
+                        }
+                    }
                 } else {
                     /* For other elements, use the existing matching logic */
                     for (attr_node *a = attr_list; a; a = a->next, idx++) {
@@ -728,10 +855,8 @@ char *apex_render_html_with_attributes(cmark_node *document, int options) {
                         /* Try fingerprint match first (works for both block and inline) */
                         if (a->text_fingerprint && fp_idx > 0 &&
                             strncmp(a->text_fingerprint, html_fingerprint, 50) == 0) {
-                            /* For inline elements, also check element_index to handle duplicates.
-                             * (Images with same src use sequential matching in the branch above.) */
-                            if (elem_type == CMARK_NODE_LINK || elem_type == CMARK_NODE_IMAGE ||
-                                elem_type == CMARK_NODE_STRONG || elem_type == CMARK_NODE_EMPH ||
+                            /* For inline elements, also check element_index to handle duplicates. */
+                            if (elem_type == CMARK_NODE_STRONG || elem_type == CMARK_NODE_EMPH ||
                                 elem_type == CMARK_NODE_CODE) {
                                 if (a->element_index == elem_idx) {
                                     matching = a;
@@ -896,9 +1021,12 @@ char *apex_render_html_with_attributes(cmark_node *document, int options) {
                                 /* Build <picture> with <source> elements and <img> fallback */
                                 char *webp_srcset = extract_data_apex_picture_srcset(matching->attrs, "webp");
                                 char *avif_srcset = extract_data_apex_picture_srcset(matching->attrs, "avif");
+                                char *img_fallback_attrs = filter_img_fallback_attrs(matching->attrs);
 
-                                /* Strip data-apex-* from attrs for the img */
-                                size_t cap = 512 + (src ? strlen(src) * 2 : 0) + (webp_srcset ? strlen(webp_srcset) : 0) + (avif_srcset ? strlen(avif_srcset) : 0);
+                                size_t cap = 512 + (src ? strlen(src) * 2 : 0) +
+                                             (webp_srcset ? strlen(webp_srcset) : 0) +
+                                             (avif_srcset ? strlen(avif_srcset) : 0) +
+                                             (img_fallback_attrs ? strlen(img_fallback_attrs) : 0);
                                 replacement = malloc(cap);
                                 if (replacement) {
                                     char *w = replacement;
@@ -906,15 +1034,25 @@ char *apex_render_html_with_attributes(cmark_node *document, int options) {
                                     if (avif_srcset) w += snprintf(w, cap - (size_t)(w - replacement), "<source type=\"image/avif\" srcset=\"%s\">", avif_srcset);
                                     if (webp_srcset) w += snprintf(w, cap - (size_t)(w - replacement), "<source type=\"image/webp\" srcset=\"%s\">", webp_srcset);
                                     /* Preserve title on img for caption logic (apex_convert_image_captions) */
+                                    const char *img_attrs = (img_fallback_attrs && *img_fallback_attrs) ? img_fallback_attrs : NULL;
                                     if (title && *title) {
-                                        w += snprintf(w, cap - (size_t)(w - replacement), "<img src=\"%s\" alt=\"%s\" title=\"%s\"></picture>", src, alt, title);
+                                        if (img_attrs) {
+                                            w += snprintf(w, cap - (size_t)(w - replacement), "<img src=\"%s\" alt=\"%s\" title=\"%s\" %s></picture>", src, alt, title, img_attrs);
+                                        } else {
+                                            w += snprintf(w, cap - (size_t)(w - replacement), "<img src=\"%s\" alt=\"%s\" title=\"%s\"></picture>", src, alt, title);
+                                        }
                                     } else {
-                                        w += snprintf(w, cap - (size_t)(w - replacement), "<img src=\"%s\" alt=\"%s\"></picture>", src, alt);
+                                        if (img_attrs) {
+                                            w += snprintf(w, cap - (size_t)(w - replacement), "<img src=\"%s\" alt=\"%s\" %s></picture>", src, alt, img_attrs);
+                                        } else {
+                                            w += snprintf(w, cap - (size_t)(w - replacement), "<img src=\"%s\" alt=\"%s\"></picture>", src, alt);
+                                        }
                                     }
                                     repl_len = (size_t)(w - replacement);
                                 }
                                 free(webp_srcset);
                                 free(avif_srcset);
+                                free(img_fallback_attrs);
                             }
 
                             if (replacement && repl_len > 0 && repl_len <= remaining) {
@@ -2764,6 +2902,164 @@ static void apex_trim_attr_value(const char *s, size_t len,
     *out_len = (size_t)(end - start);
 }
 
+/**
+ * Rewrite img alt text and optionally strip fig-alt attribute.
+ * alt_val/alt_len and new_alt/new_alt_len are the inner text (no quotes).
+ * Caller must free.
+ */
+static char *apex_img_rewrite_alt_and_strip(const char *tag_start, const char *tag_end,
+                                            const char *alt_val, size_t alt_len,
+                                            const char *new_alt, size_t new_alt_len,
+                                            const char *strip_start, const char *strip_end) {
+    if (!tag_start || !tag_end || tag_end < tag_start || !alt_val || alt_len == 0 ||
+        !new_alt || new_alt_len == 0) {
+        return NULL;
+    }
+
+    const char *alt_value_end = alt_val + alt_len;
+    if (alt_value_end > tag_end + 1) {
+        return NULL;
+    }
+
+    size_t head_len = (size_t)(alt_val - tag_start);
+    const char *suffix_start;
+    size_t suffix_len;
+
+    if (strip_start && strip_end && strip_end > strip_start &&
+        strip_start >= alt_value_end && strip_end <= tag_end + 1) {
+        /* fig-alt attribute removed: emit closing quote then skip to after it */
+        suffix_start = strip_end;
+        suffix_len = (size_t)(tag_end + 1 - suffix_start);
+        size_t out_len = head_len + new_alt_len + 1 + suffix_len;
+
+        char *out = malloc(out_len + 1);
+        if (!out) {
+            return NULL;
+        }
+
+        char *w = out;
+        memcpy(w, tag_start, head_len);
+        w += head_len;
+        memcpy(w, new_alt, new_alt_len);
+        w += new_alt_len;
+        *w++ = '"';
+        memcpy(w, suffix_start, suffix_len);
+        w[suffix_len] = '\0';
+        return out;
+    }
+
+    suffix_start = alt_value_end;
+    suffix_len = (size_t)(tag_end + 1 - suffix_start);
+    size_t out_len = head_len + new_alt_len + suffix_len;
+
+    char *out = malloc(out_len + 1);
+    if (!out) {
+        return NULL;
+    }
+
+    char *w = out;
+    memcpy(w, tag_start, head_len);
+    w += head_len;
+    memcpy(w, new_alt, new_alt_len);
+    w += new_alt_len;
+    memcpy(w, suffix_start, suffix_len);
+    w[suffix_len] = '\0';
+    return out;
+}
+
+/**
+ * Copy an <img> tag, remove fig-alt attribute, and set alt to the fig-alt value.
+ * Caller must free the returned string.
+ */
+static char *apex_img_tag_with_fig_alt(const char *tag_start, const char *tag_end,
+                                       const char *fig_alt_val, size_t fig_alt_len,
+                                       const char *strip_start, const char *strip_end,
+                                       const char *alt_val, size_t alt_len) {
+    if (!tag_start || !tag_end || tag_end < tag_start || !fig_alt_val || fig_alt_len == 0) {
+        return NULL;
+    }
+
+    if (alt_val && alt_len > 0) {
+        return apex_img_rewrite_alt_and_strip(tag_start, tag_end, alt_val, alt_len,
+                                              fig_alt_val, fig_alt_len,
+                                              strip_start, strip_end);
+    }
+
+    /* No existing alt: strip fig-alt and insert alt="..." before closing > */
+    size_t tag_len = (size_t)(tag_end - tag_start + 1);
+    size_t strip_len = 0;
+    if (strip_start && strip_end && strip_end > strip_start &&
+        strip_start >= tag_start && strip_end <= tag_end + 1) {
+        strip_len = (size_t)(strip_end - strip_start);
+    }
+
+    size_t cap = tag_len + fig_alt_len + 64;
+    if (strip_len > 0 && strip_len < tag_len) {
+        cap = tag_len - strip_len + fig_alt_len + 64;
+    }
+    char *buf = malloc(cap);
+    if (!buf) {
+        return NULL;
+    }
+
+    char *p = buf;
+    if (strip_len > 0) {
+        size_t head = (size_t)(strip_start - tag_start);
+        memcpy(p, tag_start, head);
+        p += head;
+        size_t tail = (size_t)(tag_end + 1 - strip_end);
+        memcpy(p, strip_end, tail);
+        p += tail;
+        *p = '\0';
+    } else {
+        memcpy(buf, tag_start, tag_len);
+        buf[tag_len] = '\0';
+        p = buf + tag_len;
+    }
+
+    char *gt = strrchr(buf, '>');
+    if (!gt) {
+        free(buf);
+        return NULL;
+    }
+
+    char fig_alt_buf[512];
+    size_t use_len = fig_alt_len;
+    if (use_len >= sizeof(fig_alt_buf)) {
+        use_len = sizeof(fig_alt_buf) - 1;
+    }
+    memcpy(fig_alt_buf, fig_alt_val, use_len);
+    fig_alt_buf[use_len] = '\0';
+
+    char insert[600];
+    int n = snprintf(insert, sizeof(insert), " alt=\"%s\"", fig_alt_buf);
+    if (n < 0 || (size_t)n >= sizeof(insert)) {
+        free(buf);
+        return NULL;
+    }
+
+    size_t tail_len = strlen(gt);
+    size_t new_len = (size_t)(gt - buf) + (size_t)n + tail_len;
+    if (new_len + 1 > cap) {
+        char *grown = realloc(buf, new_len + 32);
+        if (!grown) {
+            free(buf);
+            return NULL;
+        }
+        buf = grown;
+        gt = strrchr(buf, '>');
+        if (!gt) {
+            free(buf);
+            return NULL;
+        }
+        tail_len = strlen(gt);
+    }
+
+    memmove(gt + n, gt, tail_len + 1);
+    memcpy(gt, insert, (size_t)n);
+    return buf;
+}
+
 /**
  * Convert <img> tags to <figure> with <figcaption> when alt/title/caption are present.
  * If caption="TEXT" is present, always wrap. Otherwise when enable_image_captions,
@@ -2948,6 +3244,10 @@ char *apex_convert_image_captions(const char *html, bool enable_image_captions,
             size_t caption_len = 0;
             const char *caption_attr_start = NULL; /* start of caption attr (for stripping) */
             const char *caption_attr_end = NULL;
+            const char *fig_alt_val = NULL;
+            size_t fig_alt_len = 0;
+            const char *fig_alt_attr_start = NULL;
+            const char *fig_alt_attr_end = NULL;
 
             const char *q = attr_start;
             while (q < attr_end) {
@@ -3001,6 +3301,12 @@ char *apex_convert_image_captions(const char *html, bool enable_image_captions,
                         (strncasecmp(name_start, "title", 5) == 0)) {
                         title_val = value_start;
                         title_len = (size_t)(value_end - value_start);
+                    } else if (name_len == 7 &&
+                               (strncasecmp(name_start, "fig-alt", 7) == 0)) {
+                        fig_alt_val = value_start;
+                        fig_alt_len = (size_t)(value_end - value_start);
+                        fig_alt_attr_start = (name_start > attr_start && isspace((unsigned char)name_start[-1])) ? name_start - 1 : name_start;
+                        fig_alt_attr_end = q;
                     } else if (name_len == 3 &&
                                (strncasecmp(name_start, "alt", 3) == 0)) {
                         alt_val = value_start;
@@ -3043,8 +3349,42 @@ char *apex_convert_image_captions(const char *html, bool enable_image_captions,
                 }
             }
 
+            /* Quarto/Pandoc: fig-alt is accessibility alt; markdown alt text is the caption */
+            if (fig_alt_val && fig_alt_len > 0 && alt_val && alt_len > 0 && !use_caption_attr) {
+                apex_trim_attr_value(alt_val, alt_len, &caption, &caption_text_len);
+            }
+
+            char *fig_alt_tag = NULL;
+            if (fig_alt_val && fig_alt_len > 0) {
+                fig_alt_tag = apex_img_tag_with_fig_alt(tag_start, tag_end, fig_alt_val, fig_alt_len,
+                                                        fig_alt_attr_start, fig_alt_attr_end,
+                                                        alt_val, alt_len);
+            }
+
             if (!caption || caption_text_len == 0) {
-                /* No caption - copy tag as-is */
+                /* No caption - copy tag as-is (apply fig-alt alt rewrite when present) */
+                if (fig_alt_tag) {
+                    size_t tag_len = strlen(fig_alt_tag);
+                    if (tag_len >= remaining) {
+                        size_t used = write - output;
+                        size_t new_cap = (used + tag_len + 1) * 2;
+                        char *new_out = realloc(output, new_cap);
+                        if (!new_out) {
+                            free(fig_alt_tag);
+                            free(output);
+                            return NULL;
+                        }
+                        output = new_out;
+                        write = output + used;
+                        remaining = new_cap - used;
+                    }
+                    memcpy(write, fig_alt_tag, tag_len);
+                    write += tag_len;
+                    remaining -= tag_len;
+                    free(fig_alt_tag);
+                    read = tag_end + 1;
+                    continue;
+                }
                 size_t tag_len = (size_t)(tag_end - tag_start + 1);
                 if (tag_len >= remaining) {
                     size_t used = write - output;
@@ -3086,6 +3426,28 @@ char *apex_convert_image_captions(const char *html, bool enable_image_captions,
                 }
                 if (figure_depth > 0) {
                     /* Already inside a figure - copy img tag as-is, no extra wrap */
+                    if (fig_alt_tag) {
+                        size_t tag_len = strlen(fig_alt_tag);
+                        if (tag_len >= remaining) {
+                            size_t used = write - output;
+                            size_t new_cap = (used + tag_len + 1) * 2;
+                            char *new_out = realloc(output, new_cap);
+                            if (!new_out) {
+                                free(fig_alt_tag);
+                                free(output);
+                                return NULL;
+                            }
+                            output = new_out;
+                            write = output + used;
+                            remaining = new_cap - used;
+                        }
+                        memcpy(write, fig_alt_tag, tag_len);
+                        write += tag_len;
+                        remaining -= tag_len;
+                        free(fig_alt_tag);
+                        read = tag_end + 1;
+                        continue;
+                    }
                     size_t tag_len = (size_t)(tag_end - tag_start + 1);
                     if (tag_len >= remaining) {
                         size_t used = write - output;
@@ -3115,7 +3477,9 @@ char *apex_convert_image_captions(const char *html, bool enable_image_captions,
 
             /* When we have caption= attribute, output img tag without it (strip caption attr) */
             size_t img_tag_output_len;
-            if (caption_attr_start != NULL && caption_attr_end != NULL) {
+            if (fig_alt_tag) {
+                img_tag_output_len = strlen(fig_alt_tag);
+            } else if (caption_attr_start != NULL && caption_attr_end != NULL) {
                 img_tag_output_len = (size_t)(caption_attr_start - tag_start) +
                     (size_t)(tag_end + 1 - caption_attr_end);
             } else {
@@ -3145,7 +3509,13 @@ char *apex_convert_image_captions(const char *html, bool enable_image_captions,
             remaining -= strlen(figure_open);
 
             /* Write <img ...> tag (omitting caption attribute if present) */
-            if (caption_attr_start != NULL && caption_attr_end != NULL) {
+            if (fig_alt_tag) {
+                memcpy(write, fig_alt_tag, img_tag_output_len);
+                write += img_tag_output_len;
+                remaining -= img_tag_output_len;
+                free(fig_alt_tag);
+                fig_alt_tag = NULL;
+            } else if (caption_attr_start != NULL && caption_attr_end != NULL) {
                 size_t part1 = (size_t)(caption_attr_start - tag_start);
                 memcpy(write, tag_start, part1);
                 write += part1;