apex-ruby 1.0.38 → 1.0.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae9f539a2b1544d0df515de411fde4d0f3aeb30ab7ca7b6f479b11aebf7ffad9
-  data.tar.gz: cc8bbde52b5809eed92e053ba83f036ebd0165359f66b2948cda19d0302a49f9
+  metadata.gz: f037626c97e2d9d1da593da4e5cfe66b74bac805d7bad91e8f5547ff676cb394
+  data.tar.gz: a1ef5604a103f328a970246606c4e9c79b2ea6ffece769532250da7499dc287d
 SHA512:
-  metadata.gz: d249897d7cb049c2e2321d9eb611c7e7130b72c3a1d3eab7a9397b78d70de1c142cf149056ef15bb55ebe6748d1102f0e5cea56ce3343db7db0edac19848fc30
-  data.tar.gz: 5806b9b11104918b2f115f557cb032a339b03017375b08cb4ce15168ed0886837500b6aec2deedd2aaf15af45abfacf40cc5df93a7cabdbe2b8033c9b6579ac1
+  metadata.gz: b6f994047113301b183aa7529089d6342f6847ace386ceb281cd80675b5ef79afc6a7c423318357533c03102b24916e8b7e20405c750b903189674a2cb321380
+  data.tar.gz: 90101aea55503ce808d9cc4f6018c466ff9a03791deac096f4e13e85858536beb5abe6dabc7d90e89a0f2fe91b7fde7bdd9d054bc841d99b54fd45679b98d344

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 41
+#define APEX_VERSION_STRING "1.1.41"
 
 /**
  * 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/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.39"
   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.39
 platform: ruby
 authors:
 - Brett Terpstra