apex-ruby 1.0.32 → 1.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89a42e9eb766a3bae89c288dad1c44f1f8db2adcc558053835c64a157359a49b
-  data.tar.gz: 12da83980eb83177a45bc3796df1d52e0e62edd9c3ff94974db77f02099fc90b
+  metadata.gz: 55f4be7471b1a5d14cc4f772e5a92fed588dfa22f746d2ebc8417fb9b13758d7
+  data.tar.gz: 27aa2109e8bdad8f123f5cdfd6f7dee7a56947f4f47a06d653ca6fde9adf558c
 SHA512:
-  metadata.gz: 1da4b9b6b8cf73e42f8034584975c8b11b9be7833c7e22bcb6dee7151f5426836edf8984c27dbaabc67e5e855d4cf092f4cd8b45d8fd7f87851c37ca448c53a9
-  data.tar.gz: 599ee35216be91ff2fa7cf1b981e8c6d7001744310f6ae463277068331317440cdeab9e8edbcd299ecd29e459ce5932004dbb3776eaeca200efdfe5ad3f11762
+  metadata.gz: e3d8fb224ae6eaebe856a9651319c806e3031d3720a7261c264063f8f0777dd522a8547175dfdd393bb83aafb1f5a7ad8b7ee7a49d18cdae9124f279051e7bf9
+  data.tar.gz: a60e981f839d51dae0b93e4e088ba43fe575800b951e85d97b35379af434a93ef968d84ebcab74e137dd916023682ff06b1023c4a14574a0224a720490054c88

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 34
-#define APEX_VERSION_STRING "1.1.34"
+#define APEX_VERSION_PATCH 36
+#define APEX_VERSION_STRING "1.1.36"
 
 /**
  * Processor compatibility modes
@@ -150,7 +150,7 @@ typedef struct apex_options {
     bool enable_grid_tables;  /* Enable Pandoc grid table syntax (preprocess to pipe tables) */
 
     /* Critic markup mode */
-    int critic_mode;  /* 0=markup (default), 1=accept, 2=reject */
+    int critic_mode;  /* 0=accept, 1=reject, 2=markup (default) */
 
     /* Metadata handling */
     bool strip_metadata;

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

@@ -807,8 +807,8 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
 
             /* Then: check for reference link definitions: [id]: URL */
             line_start = r;
-            /* Skip leading whitespace */
-            while (*line_start == ' ' || *line_start == '\t') {
+            /* Skip leading whitespace and blockquote markers */
+            while (*line_start == ' ' || *line_start == '\t' || *line_start == '>') {
                 line_start++;
             }
             /* Check for [id]: pattern */

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

@@ -2781,6 +2781,130 @@ static bool looks_like_attr_key_equals(const char *p, const char *end) {
     return (p > key_start && p < end && *p == '=');
 }
 
+static const char *ial_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 (after indentation and
+ * blockquote markers), or 0 if the line is not a fence. */
+static size_t ial_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);
+}
+
+/**
+ * Number of bytes at pos that are code (a closed fenced block starting at
+ * this line, a code span, or an unmatched backtick run) and must be copied
+ * through untouched. Returns 0 when pos does not start code.
+ */
+static size_t ial_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 = ial_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 = ial_next_line(pos);
+                while (*line) {
+                    char close_char;
+                    const char *close_after;
+                    size_t close_len = ial_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)(ial_next_line(line) - pos);
+                        }
+                    }
+                    line = ial_next_line(line);
+                }
+                /* Unclosed fence: protect only the opening line */
+                return (size_t)(ial_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 = ial_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;
+}
+
+/* A reference definition label must open its line, after at most three
+ * spaces of indentation (blockquote markers allowed). */
+static bool ial_at_definition_start(const char *base, const char *pos) {
+    const char *p = pos;
+    for (;;) {
+        int spaces = 0;
+        while (p > base && p[-1] == ' ') {
+            p--;
+            spaces++;
+        }
+        if (spaces > 3) return false;
+        if (p == base || p[-1] == '\n' || p[-1] == '\r') return true;
+        if (p[-1] != '>') return false;
+        p--;
+    }
+}
+
+static bool ial_append_verbatim(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;
+    }
+    memcpy(*write, src, len);
+    *write += len;
+    *remaining -= len;
+    return true;
+}
+
 /**
  * Preprocess markdown to extract image attributes and URL-encode all link URLs
  */
@@ -2826,6 +2950,17 @@ char *apex_preprocess_image_attributes(const char *text, image_attr_entry **img_
     int image_index = 0;
 
     while (*read) {
+        size_t code_len = ial_code_region_len(text, read);
+        if (code_len) {
+            if (!ial_append_verbatim(&output, &write, &remaining, read, code_len)) {
+                free(output);
+                apex_free_image_attributes(local_img_attrs);
+                return NULL;
+            }
+            read += code_len;
+            continue;
+        }
+
         /* Look for inline images: ![alt](url attributes) */
         if (*read == '!' && read[1] == '[') {
             const char *img_start = read;
@@ -3244,7 +3379,7 @@ char *apex_preprocess_image_attributes(const char *text, image_attr_entry **img_
 
         /* Look for reference-style link definitions: [ref]: url attributes */
         /* Process to URL-encode URLs and extract image attributes if present */
-        if (*read == '[') {
+        if (*read == '[' && ial_at_definition_start(text, read)) {
             const char *ref_start = read;
             const char *ref_end = strchr(ref_start, ']');
             if (ref_end && ref_end[1] == ':' && (ref_end[2] == ' ' || ref_end[2] == '\t')) {
@@ -4111,6 +4246,18 @@ char *apex_preprocess_image_attributes(const char *text, image_attr_entry **img_
             bool made_expansions = false;
 
             while (*read2) {
+                size_t code_len2 = ial_code_region_len(output, read2);
+                if (code_len2) {
+                    if (!ial_append_verbatim(&expanded_output, &write2, &remaining2, read2, code_len2)) {
+                        free(expanded_output);
+                        free(output);
+                        apex_free_image_attributes(local_img_attrs);
+                        return NULL;
+                    }
+                    read2 += code_len2;
+                    continue;
+                }
+
                 /* Look for full, collapsed, and shortcut reference images. */
                 if (*read2 == '!' && read2[1] == '[') {
                     const char *img_start = read2;
@@ -4311,6 +4458,17 @@ char *apex_preprocess_image_attributes(const char *text, image_attr_entry **img_
                     size_t proc_remaining = strlen(output) * 2;
 
                     while (*proc_read) {
+                        size_t code_len3 = ial_code_region_len(output, proc_read);
+                        if (code_len3) {
+                            if (!ial_append_verbatim(&proc_output, &proc_write, &proc_remaining, proc_read, code_len3)) {
+                                free(proc_output);
+                                proc_output = NULL;
+                                break;
+                            }
+                            proc_read += code_len3;
+                            continue;
+                        }
+
                         /* Look for inline images that were just expanded */
                         if (*proc_read == '!' && proc_read[1] == '[') {
                             const char *img_start = proc_read;
@@ -4446,9 +4604,11 @@ char *apex_preprocess_image_attributes(const char *text, image_attr_entry **img_
                         }
                     }
 
-                    *proc_write = '\0';
-                    free(output);
-                    output = proc_output;
+                    if (proc_output) {
+                        *proc_write = '\0';
+                        free(output);
+                        output = proc_output;
+                    }
                 }
             }
         }

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

@@ -113,6 +113,22 @@ static all_cell *collect_all_cells(cmark_node *document) {
 /**
  * Walk AST and collect cells with attributes
  */
+/* True when the cell whose opening tag starts at `cell` contains only `marker`
+ * (or `alt`), ignoring surrounding whitespace. */
+static bool cell_is_only_marker(const char *cell, const char *marker, const char *alt) {
+    bool is_th = strncmp(cell, "<th", 3) == 0;
+    const char *content = strchr(cell, '>');
+    if (!content) return false;
+    content++;
+    const char *end = strstr(content, is_th ? "</th>" : "</td>");
+    if (!end) return false;
+    while (content < end && isspace((unsigned char)*content)) content++;
+    while (end > content && isspace((unsigned char)end[-1])) end--;
+    size_t len = (size_t)(end - content);
+    if (len == strlen(marker) && strncmp(content, marker, len) == 0) return true;
+    return alt && len == strlen(alt) && strncmp(content, alt, len) == 0;
+}
+
 static cell_attr *collect_table_cell_attributes(cmark_node *document) {
     cell_attr *list = NULL;
 
@@ -181,8 +197,7 @@ static cell_attr *collect_table_cell_attributes(cmark_node *document) {
                         attr->attributes = strdup(attrs);
                         attr->cell_text = cell_text ? strdup(cell_text) : NULL;
                         attr->next = list;
-                        list = attr;
-                    }
+                        list = attr;                    }
                 }
                 /* Count all cells (including removed ones) to match the column indices
                  * used in advanced_tables.c when finding target cells for rowspan.
@@ -2076,41 +2091,9 @@ char *apex_inject_table_attributes(const char *html, cmark_node *document, int c
                 }
             }
 
-            /* Also check if this cell contains "^^" (rowspan marker) - these should be removed */
-            /* Check both the preview and the actual content in the HTML */
-            bool is_rowspan_marker = (strstr(cell_preview, "^^") != NULL);
-            if (!is_rowspan_marker) {
-                /* Also check the actual HTML content for "^^" */
-                const char *content_check = strstr(read, ">");
-                if (content_check) {
-                    const char *close_check = strstr(content_check + 1, "</td>");
-                    if (!close_check) close_check = strstr(content_check + 1, "</th>");
-                    if (close_check && close_check - content_check - 1 < 100) {
-                        char check_buf[100];
-                        strncpy(check_buf, content_check + 1, close_check - content_check - 1);
-                        check_buf[close_check - content_check - 1] = '\0';
-                        is_rowspan_marker = (strstr(check_buf, "^^") != NULL);
-                    }
-                }
-            }
-
-            /* Also check if this cell contains "<< " or "&lt;&lt;" (colspan marker) - these should be removed */
-            /* Check both the preview and the actual content in the HTML */
-            bool is_colspan_marker = (strstr(cell_preview, "<<") != NULL || strstr(cell_preview, "&lt;&lt;") != NULL);
-            if (!is_colspan_marker) {
-                /* Also check the actual HTML content for "<< " or "&lt;&lt;" */
-                const char *content_check = strstr(read, ">");
-                if (content_check) {
-                    const char *close_check = strstr(content_check + 1, "</td>");
-                    if (!close_check) close_check = strstr(content_check + 1, "</th>");
-                    if (close_check && close_check - content_check - 1 < 100) {
-                        char check_buf[100];
-                        strncpy(check_buf, content_check + 1, close_check - content_check - 1);
-                        check_buf[close_check - content_check - 1] = '\0';
-                        is_colspan_marker = (strstr(check_buf, "<<") != NULL || strstr(check_buf, "&lt;&lt;") != NULL);
-                    }
-                }
-            }
+            /* Cells holding only a span marker (^^ or <<) are removed */
+            bool is_rowspan_marker = cell_is_only_marker(read, "^^", NULL);
+            bool is_colspan_marker = cell_is_only_marker(read, "&lt;&lt;", "<<");
 
             /* Check if this cell should be removed:
              * 1. If it's matched and marked for removal

data/lib/apex/version.rb

@@ -6,7 +6,7 @@ module Apex
   # via Apex::Native.version.
   module Version
     # Current gem version.
-    VERSION = "1.0.32"
+    VERSION = "1.0.34"
   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.32
+  version: 1.0.34
 platform: ruby
 authors:
 - Brett Terpstra