apex-ruby 1.0.38 → 1.0.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae9f539a2b1544d0df515de411fde4d0f3aeb30ab7ca7b6f479b11aebf7ffad9
-  data.tar.gz: cc8bbde52b5809eed92e053ba83f036ebd0165359f66b2948cda19d0302a49f9
+  metadata.gz: ee084bd77c91c213aa431c0485b23ec3a15106ee3f341d92e5885f29c8351c93
+  data.tar.gz: 7840707f775f33a7562734f60e5d69db520a93d98e95d9450483e684972d01e6
 SHA512:
-  metadata.gz: d249897d7cb049c2e2321d9eb611c7e7130b72c3a1d3eab7a9397b78d70de1c142cf149056ef15bb55ebe6748d1102f0e5cea56ce3343db7db0edac19848fc30
-  data.tar.gz: 5806b9b11104918b2f115f557cb032a339b03017375b08cb4ce15168ed0886837500b6aec2deedd2aaf15af45abfacf40cc5df93a7cabdbe2b8033c9b6579ac1
+  metadata.gz: d3e0f7af016badd58f00b1fa33742c4ee87ec6a369480e62867252fb3a13a5d3fb6b994abb63931860ddfbf94bed8dc50f959ad2c15d900d8c05c0499b99fd05
+  data.tar.gz: dbb6ea6f6087e1bc558d1fe55003061bb7ad76b6992a6ff80197ef6edf1abb3839c5ee494afaebcb7c421740badd4a675d0dbda8585ed73f524b4186f5c9b4f6

data/ext/apex_ext/apex_src/include/apex/apex.h

@@ -21,8 +21,8 @@ typedef struct cmark_node cmark_node;
 
 #define APEX_VERSION_MAJOR 1
 #define APEX_VERSION_MINOR 1
-#define APEX_VERSION_PATCH 40
-#define APEX_VERSION_STRING "1.1.40"
+#define APEX_VERSION_PATCH 43
+#define APEX_VERSION_STRING "1.1.43"
 
 /**
  * Processor compatibility modes

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

@@ -278,23 +278,490 @@ void apex_process_critic_markup_in_tree(cmark_node *node, critic_mode_t mode) {
     }
 }
 
+static const char *critic_next_line(const char *p) {
+    while (*p && *p != '\n' && *p != '\r') p++;
+    if (*p == '\r' && p[1] == '\n') return p + 2;
+    return *p ? p + 1 : p;
+}
+
+/* Length of a ``` or ~~~ fence run opening the line, or 0. */
+static size_t critic_fence_run(const char *line, char *fence_char, const char **after_run) {
+    const char *p = line;
+    while (*p == ' ' || *p == '\t' || *p == '>') p++;
+    if (*p != '`' && *p != '~') return 0;
+    char c = *p;
+    const char *run = p;
+    while (*p == c) p++;
+    if (p - run < 3) return 0;
+    *fence_char = c;
+    *after_run = p;
+    return (size_t)(p - run);
+}
+
+/* Bytes at pos that are a fenced block or code span and must be copied
+ * through untouched. Returns 0 when pos does not start code. */
+static size_t critic_code_region_len(const char *base, const char *pos) {
+    bool line_start = (pos == base || pos[-1] == '\n' || pos[-1] == '\r');
+    if (line_start) {
+        char fence_char;
+        const char *after;
+        size_t open_len = critic_fence_run(pos, &fence_char, &after);
+        if (open_len) {
+            bool valid = true;
+            if (fence_char == '`') {
+                for (const char *q = after; *q && *q != '\n' && *q != '\r'; q++) {
+                    if (*q == '`') { valid = false; break; }
+                }
+            }
+            if (valid) {
+                const char *line = critic_next_line(pos);
+                while (*line) {
+                    char close_char;
+                    const char *close_after;
+                    size_t close_len = critic_fence_run(line, &close_char, &close_after);
+                    if (close_len >= open_len && close_char == fence_char) {
+                        while (*close_after == ' ' || *close_after == '\t') close_after++;
+                        if (!*close_after || *close_after == '\n' || *close_after == '\r') {
+                            return (size_t)(critic_next_line(line) - pos);
+                        }
+                    }
+                    line = critic_next_line(line);
+                }
+                /* Unclosed fence: protect only the opening line */
+                return (size_t)(critic_next_line(pos) - pos);
+            }
+        }
+    }
+
+    if (*pos != '`') return 0;
+
+    size_t backslashes = 0;
+    for (const char *b = pos; b > base && b[-1] == '\\'; b--) backslashes++;
+    if (backslashes % 2) return 1;
+
+    const char *p = pos;
+    while (*p == '`') p++;
+    size_t open_len = (size_t)(p - pos);
+
+    /* Code spans may wrap lines but end at a blank line */
+    while (*p) {
+        if (*p == '\n' || *p == '\r') {
+            const char *next = critic_next_line(p);
+            const char *q = next;
+            while (*q == ' ' || *q == '\t' || *q == '>') q++;
+            if (!*q || *q == '\n' || *q == '\r') break;
+            p = next;
+            continue;
+        }
+        if (*p == '`') {
+            const char *run = p;
+            while (*p == '`') p++;
+            if ((size_t)(p - run) == open_len) return (size_t)(p - pos);
+            continue;
+        }
+        p++;
+    }
+    return open_len;
+}
+
+/* Indented code blocks follow the CommonMark rules: four spaces or a tab
+ * at the current container, and they cannot interrupt a paragraph. List
+ * continuations and paragraph lines stay eligible for critic markup. */
+
+typedef enum {
+    CRITIC_BOX_QUOTE,
+    CRITIC_BOX_ITEM
+} critic_box_kind;
+
+typedef struct {
+    critic_box_kind kind;
+    int need;         /* ITEM: columns required to continue */
+    bool has_content; /* ITEM has a child block */
+} critic_box;
+
+typedef struct {
+    critic_box stack[32];
+    int depth;
+    bool in_paragraph;
+    bool in_code;
+} critic_blocks;
+
+static int critic_col_add(int col, char c) {
+    if (c == '\t') return col + (4 - (col % 4));
+    return col + 1;
+}
+
+static bool critic_line_blank(const char *p) {
+    while (*p == ' ' || *p == '\t') p++;
+    return *p == '\0' || *p == '\n' || *p == '\r';
+}
+
+static const char *critic_skip_indent(const char *p, int *col, int *indent) {
+    int start = *col;
+    while (*p == ' ' || *p == '\t') {
+        *col = critic_col_add(*col, *p);
+        p++;
+    }
+    *indent = *col - start;
+    return p;
+}
+
+/* Consume exactly `columns` of indent. A tab may be only partly consumed. */
+static const char *critic_advance_columns(const char *p, int *col, int columns) {
+    int target = *col + columns;
+    while (*p && *p != '\n' && *p != '\r' && *col < target) {
+        if (*p == '\t') {
+            int next = critic_col_add(*col, '\t');
+            if (next > target) {
+                *col = target;
+                return p;
+            }
+            *col = next;
+            p++;
+        } else {
+            *col += 1;
+            p++;
+        }
+    }
+    return p;
+}
+
+static bool critic_match_quote(const char *p, int col, const char **out, int *out_col) {
+    int c = col;
+    int indent = 0;
+    const char *q = critic_skip_indent(p, &c, &indent);
+    if (indent > 3 || *q != '>') return false;
+    q++;
+    c += 1;
+    if (*q == ' ' || *q == '\t') {
+        c = critic_col_add(c, *q);
+        q++;
+    }
+    *out = q;
+    *out_col = c;
+    return true;
+}
+
+/* 1 = bullet, 2 = ordered. len is the marker without trailing space. */
+static int critic_list_marker(const char *p, int *len, int *ordered_start) {
+    if (*p == '-' || *p == '+' || *p == '*') {
+        char n = p[1];
+        if (n == ' ' || n == '\t' || n == '\n' || n == '\r' || n == '\0') {
+            *len = 1;
+            *ordered_start = 0;
+            return 1;
+        }
+        return 0;
+    }
+    if (*p >= '1' && *p <= '9') {
+        int i = 0;
+        int num = 0;
+        while (i < 9 && p[i] >= '0' && p[i] <= '9') {
+            num = num * 10 + (p[i] - '0');
+            i++;
+        }
+        if (i > 0 && (p[i] == '.' || p[i] == ')')) {
+            char n = p[i + 1];
+            if (n == ' ' || n == '\t' || n == '\n' || n == '\r' || n == '\0') {
+                *len = i + 1;
+                *ordered_start = num;
+                return 2;
+            }
+        }
+    }
+    return 0;
+}
+
+static bool critic_is_atx(const char *p) {
+    int n = 0;
+    while (p[n] == '#' && n < 7) n++;
+    if (n < 1 || n > 6) return false;
+    return p[n] == ' ' || p[n] == '\t' || p[n] == '\n' || p[n] == '\r' || p[n] == '\0';
+}
+
+static bool critic_is_fence_opener(const char *p) {
+    char c = *p;
+    if (c != '`' && c != '~') return false;
+    int n = 0;
+    while (p[n] == c) n++;
+    if (n < 3) return false;
+    if (c == '`') {
+        for (int i = n; p[i] && p[i] != '\n' && p[i] != '\r'; i++) {
+            if (p[i] == '`') return false;
+        }
+    }
+    return true;
+}
+
+/* Thematic break, or a setext underline when a paragraph is open. */
+static bool critic_is_rule(const char *p, bool in_paragraph) {
+    char kind = 0;
+    int count = 0;
+    bool spaced = false;
+    for (const char *q = p; *q && *q != '\n' && *q != '\r'; q++) {
+        if (*q == ' ' || *q == '\t') {
+            if (count > 0) spaced = true;
+            continue;
+        }
+        if (*q != '-' && *q != '_' && *q != '*' && *q != '=') return false;
+        if (!kind) kind = *q;
+        else if (*q != kind) return false;
+        count++;
+    }
+    if (count < 1 || !kind) return false;
+    if (!spaced && in_paragraph && (kind == '-' || kind == '=') && count >= 1) return true;
+    if (!spaced && count >= 3 && (kind == '-' || kind == '_' || kind == '*')) return true;
+    if (spaced && count >= 3 && (kind == '-' || kind == '_' || kind == '*')) return true;
+    return false;
+}
+
+static int critic_match_boxes(const char *line, const critic_blocks *st,
+                              const char **p, int *col) {
+    *p = line;
+    *col = 0;
+    int matched = 0;
+    bool blank = critic_line_blank(line);
+    for (int i = 0; i < st->depth; i++) {
+        if (st->stack[i].kind == CRITIC_BOX_QUOTE) {
+            const char *q;
+            int c;
+            if (!critic_match_quote(*p, *col, &q, &c)) break;
+            *p = q;
+            *col = c;
+            matched++;
+        } else if (blank) {
+            if (!st->stack[i].has_content) break;
+            matched++;
+        } else {
+            int indent = 0;
+            int c = *col;
+            critic_skip_indent(*p, &c, &indent);
+            if (indent < st->stack[i].need) break;
+            c = *col;
+            *p = critic_advance_columns(*p, &c, st->stack[i].need);
+            *col = c;
+            matched++;
+        }
+    }
+    return matched;
+}
+
+static void critic_mark_content(critic_blocks *st) {
+    for (int i = 0; i < st->depth; i++) {
+        if (st->stack[i].kind == CRITIC_BOX_ITEM) st->stack[i].has_content = true;
+    }
+}
+
+/* Would this line open a block that closes an open paragraph? */
+static bool critic_interrupts_paragraph(const char *p, int col) {
+    int indent = 0;
+    int c = col;
+    const char *q = critic_skip_indent(p, &c, &indent);
+    if (indent >= 4) return false; /* indented code cannot interrupt */
+    if (*q == '>') return true;
+    int marker_len = 0;
+    int ordered_start = 0;
+    int kind = critic_list_marker(q, &marker_len, &ordered_start);
+    if (kind == 1) return true;
+    if (kind == 2 && ordered_start == 1) return true;
+    if (critic_is_atx(q) || critic_is_fence_opener(q) || critic_is_rule(q, true)) return true;
+    return false;
+}
+
+/* Interpret the remainder of a line after open containers have been matched.
+ * Returns true when the line is indented code and must be copied verbatim. */
+static bool critic_interpret_line(critic_blocks *st, const char *p, int col) {
+    for (;;) {
+        int indent = 0;
+        int c = col;
+        const char *q = critic_skip_indent(p, &c, &indent);
+        if (*q == '\0' || *q == '\n' || *q == '\r') {
+            st->in_paragraph = false;
+            return false;
+        }
+        if (indent >= 4) {
+            if (!st->in_paragraph) {
+                st->in_code = true;
+                critic_mark_content(st);
+                return true;
+            }
+            return false;
+        }
+        if (*q == '>') {
+            if (st->depth < 32) {
+                st->stack[st->depth].kind = CRITIC_BOX_QUOTE;
+                st->stack[st->depth].need = 0;
+                st->stack[st->depth].has_content = false;
+                st->depth++;
+            }
+            q++;
+            c += 1;
+            if (*q == ' ' || *q == '\t') {
+                c = critic_col_add(c, *q);
+                q++;
+            }
+            p = q;
+            col = c;
+            st->in_paragraph = false;
+            continue;
+        }
+        int marker_len = 0;
+        int ordered_start = 0;
+        int kind = critic_list_marker(q, &marker_len, &ordered_start);
+        if (kind && !(st->in_paragraph && kind == 2 && ordered_start != 1)) {
+            int marker_offset = indent;
+            const char *after = q + marker_len;
+            int after_col = c + marker_len;
+            int save_col = after_col;
+            const char *s = after;
+            int sc = after_col;
+            while (*s == ' ' || *s == '\t') {
+                if (sc - save_col > 5) break;
+                int next = critic_col_add(sc, *s);
+                if (sc - save_col <= 5) {
+                    sc = next;
+                    s++;
+                    if (sc - save_col > 5) break;
+                } else {
+                    break;
+                }
+            }
+            int i = sc - save_col;
+            int padding;
+            const char *content;
+            int content_col;
+            if (i >= 5 || i < 1 || *s == '\0' || *s == '\n' || *s == '\r') {
+                padding = marker_len + 1;
+                content_col = after_col;
+                content = after;
+                if (i > 0) content = critic_advance_columns(after, &content_col, 1);
+            } else {
+                padding = marker_len + i;
+                content = s;
+                content_col = sc;
+            }
+            if (st->depth < 32) {
+                st->stack[st->depth].kind = CRITIC_BOX_ITEM;
+                st->stack[st->depth].need = marker_offset + padding;
+                st->stack[st->depth].has_content = false;
+                st->depth++;
+            }
+            p = content;
+            col = content_col;
+            st->in_paragraph = false;
+            st->in_code = false;
+            continue;
+        }
+        if (critic_is_fence_opener(q) || critic_is_atx(q) || critic_is_rule(q, st->in_paragraph)) {
+            st->in_paragraph = false;
+            st->in_code = false;
+            critic_mark_content(st);
+            return false;
+        }
+        st->in_paragraph = true;
+        st->in_code = false;
+        critic_mark_content(st);
+        return false;
+    }
+}
+
+/* True when this line is indented code and should be copied unchanged.
+ * Updates block state either way. Call only at the start of a line. */
+static bool critic_indented_code_line(const char *line, critic_blocks *st) {
+    const char *p;
+    int col;
+    int matched = critic_match_boxes(line, st, &p, &col);
+    bool blank = critic_line_blank(line);
+
+    if (matched < st->depth) {
+        if (st->in_paragraph && !blank && !critic_interrupts_paragraph(p, col)) {
+            return false; /* lazy continuation */
+        }
+        st->depth = matched;
+        st->in_code = false;
+        st->in_paragraph = false;
+    }
+
+    if (blank) {
+        st->in_paragraph = false;
+        if (matched < st->depth) st->in_code = false;
+        return false;
+    }
+
+    if (st->in_code) {
+        int indent = 0;
+        int c = col;
+        critic_skip_indent(p, &c, &indent);
+        if (indent >= 4) return true;
+        st->in_code = false;
+    }
+
+    return critic_interpret_line(st, p, col);
+}
+
+/* remaining counts bytes available before the terminating NUL. */
+static bool critic_append(char **buf, char **write, size_t *remaining,
+                          const char *src, size_t len) {
+    if (len >= *remaining) {
+        size_t written = (size_t)(*write - *buf);
+        size_t new_cap = (written + len + 1) * 2;
+        char *grown = realloc(*buf, new_cap);
+        if (!grown) return false;
+        *buf = grown;
+        *write = grown + written;
+        *remaining = new_cap - written - 1;
+    }
+    if (len) {
+        memcpy(*write, src, len);
+        *write += len;
+        *remaining -= len;
+    }
+    return true;
+}
+
 /**
  * Process Critic Markup in raw text (preprocessing approach)
- * This is better than postprocessing because it avoids smart typography interference
+ * This is better than postprocessing because it avoids smart typography interference.
+ * Code spans, fenced blocks, and indented code blocks are copied through
+ * so the syntax can be shown literally.
  */
 char *apex_process_critic_markup_text(const char *text, critic_mode_t mode) {
     if (!text) return NULL;
 
     size_t len = strlen(text);
-    size_t output_capacity = len * 2;  /* Generous estimate */
+    size_t output_capacity = len * 2 + 1;
     char *output = malloc(output_capacity);
     if (!output) return NULL;
 
     const char *read_pos = text;
     char *write_pos = output;
-    size_t remaining_capacity = output_capacity;
+    size_t remaining_capacity = output_capacity - 1;
+    critic_blocks blocks;
+    memset(&blocks, 0, sizeof(blocks));
 
     while (*read_pos) {
+        bool line_start = (read_pos == text || read_pos[-1] == '\n' ||
+                           (read_pos[-1] == '\r' && *read_pos != '\n'));
+        if (line_start && critic_indented_code_line(read_pos, &blocks)) {
+            const char *next = critic_next_line(read_pos);
+            if (!critic_append(&output, &write_pos, &remaining_capacity, read_pos, (size_t)(next - read_pos))) {
+                free(output);
+                return NULL;
+            }
+            read_pos = next;
+            continue;
+        }
+
+        size_t code_len = critic_code_region_len(text, read_pos);
+        if (code_len > 0) {
+            if (!critic_append(&output, &write_pos, &remaining_capacity, read_pos, code_len)) {
+                free(output);
+                return NULL;
+            }
+            read_pos += code_len;
+            continue;
+        }
+
         /* Look for { */
         if (*read_pos == '{') {
             int consumed;
@@ -310,11 +777,10 @@ char *apex_process_critic_markup_text(const char *text, critic_mode_t mode) {
                 /* Found valid critic markup - convert to HTML */
                 char *html = critic_to_html(type, content, content_len, old_text, old_len, mode);
                 if (html) {
-                    size_t html_len = strlen(html);
-                    if (html_len < remaining_capacity) {
-                        memcpy(write_pos, html, html_len);
-                        write_pos += html_len;
-                        remaining_capacity -= html_len;
+                    if (!critic_append(&output, &write_pos, &remaining_capacity, html, strlen(html))) {
+                        free(html);
+                        free(output);
+                        return NULL;
                     }
                     free(html);
                 }
@@ -324,9 +790,9 @@ char *apex_process_critic_markup_text(const char *text, critic_mode_t mode) {
         }
 
         /* Not critic markup, copy character */
-        if (remaining_capacity > 0) {
-            *write_pos++ = *read_pos;
-            remaining_capacity--;
+        if (!critic_append(&output, &write_pos, &remaining_capacity, read_pos, 1)) {
+            free(output);
+            return NULL;
         }
         read_pos++;
     }

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

@@ -993,6 +993,17 @@ static bool extract_ial_from_paragraph(cmark_node *para, apex_attributes **attrs
     return extract_ial_from_text(text, attrs_out, alds);
 }
 
+/* Drop a softbreak or hard break that only separated a removed IAL. */
+static void ial_drop_break_before(cmark_node *node) {
+    cmark_node *prev = cmark_node_previous(node);
+    if (!prev) return;
+    cmark_node_type prev_type = cmark_node_get_type(prev);
+    if (prev_type == CMARK_NODE_SOFTBREAK || prev_type == CMARK_NODE_LINEBREAK) {
+        cmark_node_unlink(prev);
+        cmark_node_free(prev);
+    }
+}
+
 /**
  * Handle span-level IAL (inline elements with attributes)
  * Example: [Link](url){: .class} or ![Image](img){: #id}
@@ -1210,7 +1221,8 @@ static bool process_span_ial_in_container(cmark_node *container, ald_entry *alds
              * Content before IAL can be: a previous sibling (e.g. text + softbreak + IAL text node), or text before IAL in this node (e.g. single node "Text\n{: .lead }"). */
             bool has_preceding_content = (cmark_node_previous(child) != NULL) || (ial_start > text);
             if (container_type == CMARK_NODE_PARAGRAPH && has_preceding_content) {
-                /* IAL was at end of text - apply to paragraph (e.g. "Text\n{: .lead }" on one block) */
+                /* IAL was at end of text - apply to this paragraph (e.g. "Text\n{: .lead }" on one block).
+                 * Inside a blockquote, "> {: .class}" follows the paragraph, so the class stays on that paragraph. */
                 char *attr_str = attributes_to_html(attrs);
                 cmark_node_set_user_data(container, attr_str);
                 apex_free_attributes(attrs);
@@ -1235,6 +1247,7 @@ static bool process_span_ial_in_container(cmark_node *container, ald_entry *alds
                             while (end >= new_text && isspace((unsigned char)*end)) *end-- = '\0';
                         }
                         if (strlen(new_text) == 0) {
+                            ial_drop_break_before(child);
                             cmark_node_unlink(child);
                             cmark_node_free(child);
                             free(new_text);
@@ -1244,6 +1257,7 @@ static bool process_span_ial_in_container(cmark_node *container, ald_entry *alds
                         }
                     }
                 } else {
+                    ial_drop_break_before(child);
                     cmark_node_unlink(child);
                     cmark_node_free(child);
                 }
@@ -1526,6 +1540,138 @@ static bool is_pure_ial_paragraph(cmark_node *para) {
  * Returns the node to free (if any), or NULL
  * Caller must free the returned node after iteration is complete
  */
+/* Copy attrs without one key="value" attribute. */
+static char *ial_attrs_without(const char *attrs, const char *name) {
+    size_t nlen = strlen(name);
+    char *out = malloc(strlen(attrs) + 1);
+    if (!out) return NULL;
+    char *write = out;
+    const char *p = attrs;
+    while (*p) {
+        while (*p && isspace((unsigned char)*p)) p++;
+        if (!*p) break;
+        const char *start = p;
+        bool drop = strncmp(p, name, nlen) == 0 && p[nlen] == '=' &&
+                    (p[nlen + 1] == '"' || p[nlen + 1] == '\'');
+        if (drop) {
+            char quote = p[nlen + 1];
+            p += nlen + 2;
+            while (*p && *p != quote) p++;
+            if (*p == quote) p++;
+            continue;
+        }
+        while (*p && !isspace((unsigned char)*p)) p++;
+        if (write != out) *write++ = ' ';
+        memcpy(write, start, (size_t)(p - start));
+        write += p - start;
+    }
+    *write = '\0';
+    return out;
+}
+
+/* True when an HTML block is only a closing tag (and comments), so a
+ * following IAL still belongs to the block before it. */
+static bool ial_html_is_closer_only(cmark_node *node) {
+    const char *html = cmark_node_get_literal(node);
+    if (!html) return false;
+    for (const char *p = html; *p; p++) {
+        if (*p == '<' && p[1] && p[1] != '/' && p[1] != '!' && p[1] != '?') {
+            return false;
+        }
+    }
+    return true;
+}
+
+/* Insert IAL attributes into the first opening tag of an HTML block.
+ * An existing class is extended instead of adding a second class attribute. */
+static char *ial_html_with_attrs(const char *html, const char *attrs) {
+    if (!html || !attrs || !*attrs) return NULL;
+
+    const char *tag = NULL;
+    for (const char *p = html; *p; p++) {
+        if (*p == '<' && p[1] && p[1] != '/' && p[1] != '!' && p[1] != '?') {
+            tag = p;
+            break;
+        }
+    }
+    if (!tag) return NULL;
+    const char *gt = strchr(tag, '>');
+    if (!gt) return NULL;
+
+    const char *class_at = NULL;
+    const char *class_val = NULL;
+    const char *class_end = NULL;
+    for (const char *p = tag + 1; p + 7 < gt; p++) {
+        if ((p == tag + 1 || isspace((unsigned char)p[-1])) && strncmp(p, "class=\"", 7) == 0) {
+            class_at = p;
+            class_val = p + 7;
+            class_end = memchr(class_val, '"', (size_t)(gt - class_val));
+            break;
+        }
+    }
+
+    const char *ial_class = NULL;
+    const char *ial_class_end = NULL;
+    const char *ial_at = strstr(attrs, "class=\"");
+    if (ial_at && (ial_at == attrs || isspace((unsigned char)ial_at[-1]))) {
+        ial_class = ial_at + 7;
+        ial_class_end = strchr(ial_class, '"');
+        if (!ial_class_end) ial_class = NULL;
+    }
+
+    char *extra = NULL;
+    char *merged_class = NULL;
+    if (class_at && class_end && ial_class) {
+        size_t old_len = (size_t)(class_end - class_val);
+        size_t add_len = (size_t)(ial_class_end - ial_class);
+        merged_class = malloc(old_len + add_len + 2);
+        if (!merged_class) return NULL;
+        memcpy(merged_class, class_val, old_len);
+        merged_class[old_len] = ' ';
+        memcpy(merged_class + old_len + 1, ial_class, add_len);
+        merged_class[old_len + 1 + add_len] = '\0';
+        extra = ial_attrs_without(attrs, "class");
+    } else {
+        extra = strdup(attrs);
+    }
+    if (!extra) {
+        free(merged_class);
+        return NULL;
+    }
+
+    size_t html_len = strlen(html);
+    size_t extra_len = strlen(extra);
+    size_t merged_len = merged_class ? strlen(merged_class) : 0;
+    char *out = malloc(html_len + extra_len + merged_len + 2);
+    if (!out) {
+        free(extra);
+        free(merged_class);
+        return NULL;
+    }
+    char *write = out;
+    if (merged_class && class_val && class_end) {
+        memcpy(write, html, (size_t)(class_val - html));
+        write += class_val - html;
+        memcpy(write, merged_class, merged_len);
+        write += merged_len;
+        memcpy(write, class_end, (size_t)(gt - class_end));
+        write += gt - class_end;
+    } else {
+        memcpy(write, html, (size_t)(gt - html));
+        write += gt - html;
+    }
+    if (extra_len > 0) {
+        *write++ = ' ';
+        memcpy(write, extra, extra_len);
+        write += extra_len;
+    }
+    memcpy(write, gt, html_len - (size_t)(gt - html) + 1);
+
+    free(extra);
+    free(merged_class);
+    return out;
+}
+
 static cmark_node *process_node_ial(cmark_node *node, ald_entry *alds) {
     if (!node) return NULL;
 
@@ -1570,30 +1716,34 @@ static cmark_node *process_node_ial(cmark_node *node, ald_entry *alds) {
         /* No span IAL found, fall through to check for next-line IAL */
     }
 
-    /* Only certain block types can have IAL after them */
+    /* Any block can take an IAL on the following line. */
     if (type != CMARK_NODE_HEADING &&
         type != CMARK_NODE_PARAGRAPH &&
         type != CMARK_NODE_BLOCK_QUOTE &&
         type != CMARK_NODE_CODE_BLOCK &&
         type != CMARK_NODE_LIST &&
         type != CMARK_NODE_ITEM &&
-        type != CMARK_NODE_TABLE) {  /* Tables can have IAL */
+        type != CMARK_NODE_TABLE &&
+        type != CMARK_NODE_THEMATIC_BREAK &&
+        type != CMARK_NODE_HTML_BLOCK) {
         return NULL;  /* No node to free */
     }
 
 
-    /* Look at next sibling(s) for IAL paragraph (skip over HTML blocks; cmark may put </div> between paragraph and IAL) */
+    /* A pure IAL paragraph is the marker, not a block that takes another IAL. */
+    if (type == CMARK_NODE_PARAGRAPH && is_pure_ial_paragraph(node)) {
+        return NULL;
+    }
+
+    /* Look at the next sibling for an IAL paragraph. A closing-tag HTML
+     * block can sit between a paragraph and its IAL. */
     cmark_node *next = cmark_node_next(node);
     if (!next) {
         return NULL;  /* No node to free */
     }
 
-    /* Skip HTML/custom blocks so we find a following IAL paragraph (e.g. paragraph, </div> html_block, {: .lead} paragraph) */
-    while (next) {
-        cmark_node_type next_type = cmark_node_get_type(next);
-        if (next_type != CMARK_NODE_HTML_BLOCK && next_type != CMARK_NODE_CUSTOM_BLOCK) {
-            break;
-        }
+    while (next && cmark_node_get_type(next) == CMARK_NODE_HTML_BLOCK &&
+           ial_html_is_closer_only(next)) {
         next = cmark_node_next(next);
     }
 
@@ -1605,10 +1755,18 @@ static cmark_node *process_node_ial(cmark_node *node, ald_entry *alds) {
     if (is_pure_ial_paragraph(next)) {
         apex_attributes *attrs = NULL;
         if (extract_ial_from_paragraph(next, &attrs, alds)) {
-            /* Store attributes in this node */
             char *attr_str = attributes_to_html(attrs);
-            cmark_node_set_user_data(node, attr_str);
             apex_free_attributes(attrs);
+            if (type == CMARK_NODE_HTML_BLOCK) {
+                const char *literal = cmark_node_get_literal(node);
+                char *merged = ial_html_with_attrs(literal, attr_str);
+                free(attr_str);
+                if (!merged) return NULL;
+                cmark_node_set_literal(node, merged);
+                free(merged);
+            } else {
+                cmark_node_set_user_data(node, attr_str);
+            }
 
             /* Return node to be unlinked and freed after iteration completes */
             /* Don't unlink here - that invalidates the iterator */
@@ -1642,6 +1800,14 @@ void apex_process_ial_in_tree(cmark_node *node, ald_entry *alds) {
             /* Process node and collect any nodes that need to be freed */
             cmark_node *node_to_free = process_node_ial(cur, alds);
             if (node_to_free) {
+                bool already_queued = false;
+                for (size_t i = 0; i < free_count; i++) {
+                    if (nodes_to_free[i] == node_to_free) {
+                        already_queued = true;
+                        break;
+                    }
+                }
+                if (already_queued) continue;
                 /* Expand array if needed */
                 if (free_count >= free_capacity) {
                     free_capacity = free_capacity ? free_capacity * 2 : 16;
@@ -2908,6 +3074,42 @@ static bool ial_append_verbatim(char **buf, char **write, size_t *remaining,
 /**
  * Preprocess markdown to extract image attributes and URL-encode all link URLs
  */
+/* Closing ')' of a link or image destination.
+ * Quotes hide parentheses, and unquoted '(' must be balanced, so a title
+ * like "Output options (Markdown)" does not end the destination early. */
+static const char *ial_destination_closer(const char *start) {
+    int depth = 1;
+    bool in_quote = false;
+    char quote = 0;
+    const char *p = start;
+
+    if (!start) return NULL;
+    while (*p && *p != '\n' && *p != '\r') {
+        if (in_quote) {
+            if (*p == '\\' && p[1]) {
+                p += 2;
+                continue;
+            }
+            if (*p == quote) in_quote = false;
+            p++;
+            continue;
+        }
+        if (*p == '"' || *p == '\'') {
+            in_quote = true;
+            quote = *p++;
+            continue;
+        }
+        if (*p == '(') {
+            depth++;
+        } else if (*p == ')') {
+            depth--;
+            if (depth == 0) return p;
+        }
+        p++;
+    }
+    return NULL;
+}
+
 char *apex_preprocess_image_attributes(const char *text, image_attr_entry **img_attrs, apex_mode_t mode) {
     if (!text) return NULL;
 
@@ -2976,12 +3178,10 @@ char *apex_preprocess_image_attributes(const char *text, image_attr_entry **img_
                 const char *attr_start = NULL;
                 const char *paren_end = NULL;
 
-                /* Find the closing paren first */
-                p = url_start;
-                while (*p && *p != ')' && *p != '\n') p++;
-                if (*p == ')') {
-                    paren_end = p;
-                } else {
+                /* Find the closing paren first. Parentheses inside a quoted
+                 * title, and balanced parentheses in the URL, do not count. */
+                paren_end = ial_destination_closer(url_start);
+                if (!paren_end) {
                     /* Malformed - skip just the ! and continue */
                     read = img_start + 1;
                     continue;
@@ -4064,12 +4264,13 @@ char *apex_preprocess_image_attributes(const char *text, image_attr_entry **img_
                 const char *url_end = NULL;
                 const char *paren_end = NULL;
 
-                /* Find the closing paren first */
-                while (*p && *p != ')' && *p != '\n') p++;
-                if (*p == ')') {
+                /* Find the closing paren first. A quoted title may contain
+                 * parentheses; stop at a newline when the destination never closes. */
+                paren_end = ial_destination_closer(url_start);
+                if (!paren_end) {
+                    p = url_start;
+                    while (*p && *p != '\n' && *p != '\r') p++;
                     paren_end = p;
-                } else {
-                    paren_end = p; /* End at newline or end of string */
                 }
 
                 /* Scan forward looking for titles: "title", 'title', or (title) */
@@ -4483,10 +4684,9 @@ char *apex_preprocess_image_attributes(const char *text, image_attr_entry **img_
                                 const char *attr_start = NULL;
                                 const char *paren_end = NULL;
 
-                                /* Find closing paren */
-                                while (*p && *p != ')' && *p != '\n') p++;
-                                if (*p == ')') {
-                                    paren_end = p;
+                                /* Find closing paren, skipping parentheses inside quotes. */
+                                paren_end = ial_destination_closer(url_start);
+                                if (paren_end) {
                                     p = url_start;
 
                                     /* Look for attributes */

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

@@ -350,6 +350,7 @@ typedef struct {
     int strong_count;
     int emph_count;
     int code_inline_count;
+    int hr_count;
 } element_counters;
 
 /**
@@ -482,6 +483,7 @@ static void collect_nodes_with_attrs_recursive(cmark_node *node, attr_node **lis
     else if (type == CMARK_NODE_LIST) elem_idx = counters->list_count++;
     else if (type == CMARK_NODE_ITEM) elem_idx = counters->item_count++;
     else if (type == CMARK_NODE_CODE_BLOCK) elem_idx = counters->code_count++;
+    else if (type == CMARK_NODE_THEMATIC_BREAK) elem_idx = counters->hr_count++;
     /* Inline elements need indices too - each type has its own counter */
     else if (type == CMARK_NODE_LINK) elem_idx = counters->link_count++;
     else if (type == CMARK_NODE_IMAGE) elem_idx = counters->image_count++;
@@ -623,6 +625,9 @@ char *apex_render_html_with_attributes(cmark_node *document, int options) {
             } else if (tag_len == 2 && memcmp(tag_start, "li", 2) == 0) {
                 elem_type = CMARK_NODE_ITEM;
                 elem_idx = html_counters.item_count++;
+            } else if (tag_len == 2 && memcmp(tag_start, "hr", 2) == 0) {
+                elem_type = CMARK_NODE_THEMATIC_BREAK;
+                elem_idx = html_counters.hr_count++;
             } else if (tag_len == 3 && memcmp(tag_start, "pre", 3) == 0) {
                 elem_type = CMARK_NODE_CODE_BLOCK;
                 elem_idx = html_counters.code_count++;
@@ -776,13 +781,19 @@ char *apex_render_html_with_attributes(cmark_node *document, int options) {
                     }
                     html_fingerprint[fp_idx] = '\0';
                 } else {
-                    /* For block elements, extract text content */
+                    /* For block elements, extract text content.
+                     * Paragraph attributes are fingerprinted from the first text
+                     * node, which ends at a softbreak, so stop at the first newline. */
                     const char *content_start = tag_name_end;
                     while (*content_start && *content_start != '>') content_start++;
                     if (*content_start == '>') content_start++;
 
                     const char *text_p = content_start;
                     while (*text_p && *text_p != '<' && fp_idx < 50) {
+                        if (elem_type == CMARK_NODE_PARAGRAPH &&
+                            (*text_p == '\n' || *text_p == '\r')) {
+                            break;
+                        }
                         html_fingerprint[fp_idx++] = *text_p++;
                     }
                     html_fingerprint[fp_idx] = '\0';

data/lib/apex/version.rb

@@ -6,7 +6,7 @@ module Apex
   # via Apex::Native.version.
   module Version
     # Current gem version.
-    VERSION = "1.0.38"
+    VERSION = "1.0.40"
   end
 
   # Shortcut to gem version string.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: apex-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.38
+  version: 1.0.40
 platform: ruby
 authors:
 - Brett Terpstra