apex-ruby 1.0.18 → 1.0.20

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

@@ -0,0 +1,264 @@
+/**
+ * Quarto mode polish: strict lists, cross-ref markers
+ */
+
+#include "quarto_polish.h"
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+static const char *line_end_ptr(const char *p) {
+    const char *e = strchr(p, '\n');
+    return e ? e : p + strlen(p);
+}
+
+static bool append_chunk(char **out, size_t *len, size_t *cap, const char *chunk, size_t chunk_len) {
+    if (chunk_len == 0) {
+        return true;
+    }
+    if (*len + chunk_len + 1 > *cap) {
+        size_t new_cap = (*cap == 0 ? 256 : *cap * 2);
+        while (*len + chunk_len + 1 > new_cap) {
+            new_cap *= 2;
+        }
+        char *grown = realloc(*out, new_cap);
+        if (!grown) {
+            return false;
+        }
+        *out = grown;
+        *cap = new_cap;
+    }
+    memcpy(*out + *len, chunk, chunk_len);
+    *len += chunk_len;
+    (*out)[*len] = '\0';
+    return true;
+}
+
+typedef enum {
+    LINE_BLANK = 0,
+    LINE_LIST,
+    LINE_OTHER
+} line_kind;
+
+static bool line_is_blank(const char *start, const char *end) {
+    const char *p = start;
+    while (p < end && (*p == ' ' || *p == '\t' || *p == '\r')) {
+        p++;
+    }
+    return p >= end;
+}
+
+static bool line_is_list_marker(const char *start, const char *end) {
+    const char *p = start;
+    while (p < end && (*p == ' ' || *p == '\t')) {
+        p++;
+    }
+    if (p >= end) {
+        return false;
+    }
+
+    if (*p == '-' || *p == '*' || *p == '+') {
+        return (p + 1 < end && (*p == '+' || isspace((unsigned char)p[1])));
+    }
+
+    if (isdigit((unsigned char)*p)) {
+        while (p < end && isdigit((unsigned char)*p)) {
+            p++;
+        }
+        return p < end && *p == '.' && (p + 1 >= end || isspace((unsigned char)p[1]));
+    }
+
+    if (p + 3 <= end && p[0] == '(' && p[1] == '@') {
+        return true;
+    }
+
+    if ((*p == 'i' || *p == 'I') && p + 1 < end && p[1] == 'i' && p + 2 < end && p[2] == ')') {
+        return isspace((unsigned char)p[3]) || p + 3 >= end;
+    }
+    if (*p == 'i' && p + 1 < end && p[1] == ')') {
+        return isspace((unsigned char)p[2]) || p + 2 >= end;
+    }
+
+    return false;
+}
+
+static line_kind classify_line(const char *start, const char *end) {
+    if (line_is_blank(start, end)) {
+        return LINE_BLANK;
+    }
+    if (line_is_list_marker(start, end)) {
+        return LINE_LIST;
+    }
+    return LINE_OTHER;
+}
+
+char *apex_preprocess_quarto_strict_lists(const char *text) {
+    if (!text) {
+        return NULL;
+    }
+
+    size_t cap = strlen(text) * 2 + 64;
+    char *out = malloc(cap);
+    if (!out) {
+        return NULL;
+    }
+    size_t len = 0;
+    out[0] = '\0';
+    bool changed = false;
+    line_kind prev = LINE_BLANK;
+    bool in_fenced_code = false;
+
+    const char *read = text;
+    while (*read) {
+        const char *line_start = read;
+        const char *line_end = line_end_ptr(read);
+        bool at_line_start = (read == text || read[-1] == '\n');
+
+        if (at_line_start) {
+            const char *content = line_start;
+            while (content < line_end && (*content == ' ' || *content == '\t')) {
+                content++;
+            }
+            if ((size_t)(line_end - content) >= 3 && strncmp(content, "```", 3) == 0) {
+                in_fenced_code = !in_fenced_code;
+            }
+        }
+
+        if (!in_fenced_code) {
+            line_kind kind = classify_line(line_start, line_end);
+            if (kind == LINE_LIST && prev == LINE_OTHER) {
+                if (!append_chunk(&out, &len, &cap, "\n", 1)) {
+                    free(out);
+                    return NULL;
+                }
+                changed = true;
+            }
+            if (kind != LINE_BLANK) {
+                prev = kind;
+            } else {
+                prev = LINE_BLANK;
+            }
+        }
+
+        size_t line_len = (size_t)(line_end - line_start);
+        if (*line_end == '\n') {
+            line_len++;
+        }
+        if (!append_chunk(&out, &len, &cap, line_start, line_len)) {
+            free(out);
+            return NULL;
+        }
+        read = (*line_end == '\n') ? line_end + 1 : line_end;
+    }
+
+    if (!changed) {
+        free(out);
+        return NULL;
+    }
+    return out;
+}
+
+static bool xref_prefix(const char *p) {
+    static const char *prefixes[] = { "fig-", "sec-", "tbl-", "eq-", NULL };
+    for (int i = 0; prefixes[i]; i++) {
+        size_t n = strlen(prefixes[i]);
+        if (strncmp(p, prefixes[i], n) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static size_t xref_token_len(const char *start) {
+    if (*start != '@') {
+        return 0;
+    }
+    const char *p = start + 1;
+    if (!xref_prefix(p)) {
+        return 0;
+    }
+    p += 4;
+    size_t len = (size_t)(p - start);
+    while (*p && (isalnum((unsigned char)*p) || *p == '_' || *p == '-' || *p == ':')) {
+        p++;
+        len++;
+    }
+    while (len > 6 && strchr(".,;:!?", p[-1])) {
+        p--;
+        len--;
+    }
+    return len >= 6 ? len : 0;
+}
+
+char *apex_postprocess_quarto_xrefs_html(const char *html) {
+    if (!html) {
+        return NULL;
+    }
+
+    size_t cap = strlen(html) * 2 + 256;
+    char *out = malloc(cap);
+    if (!out) {
+        return NULL;
+    }
+    size_t len = 0;
+    out[0] = '\0';
+    bool changed = false;
+    bool in_tag = false;
+
+    for (const char *read = html; *read;) {
+        if (*read == '<') {
+            in_tag = true;
+            const char *gt = strchr(read, '>');
+            size_t chunk = gt ? (size_t)(gt - read + 1) : strlen(read);
+            if (!append_chunk(&out, &len, &cap, read, chunk)) {
+                free(out);
+                return NULL;
+            }
+            read += chunk;
+            if (gt) {
+                in_tag = false;
+            }
+            continue;
+        }
+
+        if (in_tag) {
+            if (!append_chunk(&out, &len, &cap, read, 1)) {
+                free(out);
+                return NULL;
+            }
+            read++;
+            continue;
+        }
+
+        size_t tok_len = xref_token_len(read);
+        if (tok_len > 0) {
+            if (!append_chunk(&out, &len, &cap, "<span class=\"quarto-xref\">", 26)) {
+                free(out);
+                return NULL;
+            }
+            if (!append_chunk(&out, &len, &cap, read, tok_len)) {
+                free(out);
+                return NULL;
+            }
+            if (!append_chunk(&out, &len, &cap, "</span>", 7)) {
+                free(out);
+                return NULL;
+            }
+            changed = true;
+            read += tok_len;
+            continue;
+        }
+
+        if (!append_chunk(&out, &len, &cap, read, 1)) {
+            free(out);
+            return NULL;
+        }
+        read++;
+    }
+
+    if (!changed) {
+        free(out);
+        return NULL;
+    }
+    return out;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Quarto mode polish: strict lists, cross-ref markers
+ */
+
+#ifndef APEX_QUARTO_POLISH_H
+#define APEX_QUARTO_POLISH_H
+
+#include <stdbool.h>
+
+/**
+ * Insert blank lines before list blocks when a non-blank line immediately
+ * precedes a list marker (Pandoc strict blank-line-before-list behavior).
+ * Returns NULL if unchanged.
+ */
+char *apex_preprocess_quarto_strict_lists(const char *text);
+
+/**
+ * Wrap Quarto cross-ref tokens (@fig-id, @sec-id, @tbl-id, @eq-id) in
+ * span.quarto-xref in HTML output. Skips content inside tags. Returns NULL if unchanged.
+ */
+char *apex_postprocess_quarto_xrefs_html(const char *html);
+
+#endif /* APEX_QUARTO_POLISH_H */

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

@@ -0,0 +1,307 @@
+/**
+ * Quarto/Pandoc shortcode shim
+ */
+
+#include "quarto_shortcodes.h"
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+static const char PAGEBREAK_HTML[] =
+    "\n\n<div class=\"mkpagebreak manualbreak\" "
+    "title=\"Page break created by marker\" "
+    "data-description=\"PAGE (Marker)\" "
+    "style=\"page-break-after:always\">"
+    "<span style=\"display:none\">&nbsp;</span></div>\n\n";
+
+static const char PAGEBREAK_MARKER[] = "{::pagebreak /}";
+
+static bool append_chunk(char **out, size_t *len, size_t *cap, const char *chunk, size_t chunk_len) {
+    if (chunk_len == 0) {
+        return true;
+    }
+    if (*len + chunk_len + 1 > *cap) {
+        size_t new_cap = (*cap == 0 ? 256 : *cap * 2);
+        while (*len + chunk_len + 1 > new_cap) {
+            new_cap *= 2;
+        }
+        char *grown = realloc(*out, new_cap);
+        if (!grown) {
+            return false;
+        }
+        *out = grown;
+        *cap = new_cap;
+    }
+    memcpy(*out + *len, chunk, chunk_len);
+    *len += chunk_len;
+    (*out)[*len] = '\0';
+    return true;
+}
+
+static bool append_str(char **out, size_t *len, size_t *cap, const char *str) {
+    if (!str) {
+        return true;
+    }
+    return append_chunk(out, len, cap, str, strlen(str));
+}
+
+static void trim_inplace(char *s) {
+    if (!s) {
+        return;
+    }
+    size_t n = strlen(s);
+    size_t start = 0;
+    while (start < n && isspace((unsigned char)s[start])) {
+        start++;
+    }
+    size_t end = n;
+    while (end > start && isspace((unsigned char)s[end - 1])) {
+        end--;
+    }
+    if (start > 0 || end < n) {
+        memmove(s, s + start, end - start);
+        s[end - start] = '\0';
+    }
+}
+
+static void strip_outer_quotes(char *s) {
+    if (!s) {
+        return;
+    }
+    trim_inplace(s);
+    size_t n = strlen(s);
+    if (n >= 2 &&
+        ((s[0] == '"' && s[n - 1] == '"') || (s[0] == '\'' && s[n - 1] == '\''))) {
+        s[n - 1] = '\0';
+        memmove(s, s + 1, n - 2);
+        s[n - 2] = '\0';
+    }
+}
+
+static const char *first_arg_token(const char *args, char *token_out, size_t token_size) {
+    if (!args || !token_out || token_size == 0) {
+        return NULL;
+    }
+    token_out[0] = '\0';
+    const char *p = args;
+    while (*p && isspace((unsigned char)*p)) {
+        p++;
+    }
+    if (!*p) {
+        return p;
+    }
+
+    if (*p == '"' || *p == '\'') {
+        char quote = *p++;
+        size_t i = 0;
+        while (*p && *p != quote && i + 1 < token_size) {
+            token_out[i++] = *p++;
+        }
+        token_out[i] = '\0';
+        if (*p == quote) {
+            p++;
+        }
+        return p;
+    }
+
+    size_t i = 0;
+    while (*p && !isspace((unsigned char)*p) && i + 1 < token_size) {
+        token_out[i++] = *p++;
+    }
+    token_out[i] = '\0';
+    return p;
+}
+
+static bool expand_shortcode(const char *name, const char *args,
+                             char **out, size_t *len, size_t *cap,
+                             bool warn_unknown, bool unsafe) {
+    if (!name || !*name) {
+        return false;
+    }
+
+    if (strcasecmp(name, "pagebreak") == 0) {
+        if (unsafe) {
+            return append_str(out, len, cap, PAGEBREAK_HTML);
+        }
+        return append_str(out, len, cap, PAGEBREAK_MARKER);
+    }
+
+    if (strcasecmp(name, "kbd") == 0) {
+        if (!append_str(out, len, cap, "{% kbd ")) {
+            return false;
+        }
+        if (args && *args) {
+            if (!append_str(out, len, cap, args)) {
+                return false;
+            }
+        }
+        return append_str(out, len, cap, " %}");
+    }
+
+    if (strcasecmp(name, "include") == 0) {
+        char path[1024];
+        first_arg_token(args, path, sizeof(path));
+        strip_outer_quotes(path);
+        if (path[0] == '\0') {
+            return false;
+        }
+        if (!append_str(out, len, cap, "<<[")) {
+            return false;
+        }
+        if (!append_str(out, len, cap, path)) {
+            return false;
+        }
+        return append_str(out, len, cap, "]");
+    }
+
+    if (warn_unknown) {
+        fprintf(stderr, "Warning: unknown Quarto shortcode '{{< %s >}}' left unchanged\n", name);
+    }
+    return false;
+}
+
+static bool try_shortcode(const char *read, const char **read_out,
+                          char **out, size_t *len, size_t *cap,
+                          bool *changed, bool warn_unknown, bool unsafe) {
+    if (read[0] != '{' || read[1] != '{') {
+        return false;
+    }
+
+    char style = read[2];
+    if (style != '<' && style != '%') {
+        return false;
+    }
+
+    const char *p = read + 3;
+    while (*p && isspace((unsigned char)*p)) {
+        p++;
+    }
+
+    char name[128];
+    size_t name_len = 0;
+    while (*p && !isspace((unsigned char)*p) && *p != style && name_len + 1 < sizeof(name)) {
+        name[name_len++] = *p++;
+    }
+    name[name_len] = '\0';
+    if (name_len == 0) {
+        return false;
+    }
+
+    while (*p && isspace((unsigned char)*p)) {
+        p++;
+    }
+
+    const char *args_start = p;
+    const char *close = strstr(p, style == '<' ? ">}}" : "%}}");
+    if (!close) {
+        return false;
+    }
+
+    char args[1024];
+    size_t args_len = (size_t)(close - args_start);
+    if (args_len >= sizeof(args)) {
+        args_len = sizeof(args) - 1;
+    }
+    memcpy(args, args_start, args_len);
+    args[args_len] = '\0';
+    trim_inplace(args);
+
+    const char *after = close + 3;
+
+    size_t before_len = *len;
+    if (!expand_shortcode(name, args, out, len, cap, warn_unknown, unsafe)) {
+        *len = before_len;
+        (*out)[*len] = '\0';
+        return false;
+    }
+
+    *changed = true;
+    *read_out = after;
+    return true;
+}
+
+static const char *line_end_ptr(const char *p) {
+    const char *e = strchr(p, '\n');
+    return e ? e : p + strlen(p);
+}
+
+static bool shortcode_in_fenced_code(const char *text, const char *shortcode) {
+    bool in_fenced_code = false;
+    const char *read = text;
+    while (read < shortcode) {
+        const char *line_start = read;
+        const char *line_end = line_end_ptr(read);
+        bool at_line_start = (read == text || read[-1] == '\n');
+        if (at_line_start) {
+            const char *content = line_start;
+            while (content < line_end && (*content == ' ' || *content == '\t')) {
+                content++;
+            }
+            if ((size_t)(line_end - content) >= 3 && strncmp(content, "```", 3) == 0) {
+                in_fenced_code = !in_fenced_code;
+            }
+        }
+        read = (*line_end == '\n') ? line_end + 1 : line_end;
+    }
+    return in_fenced_code;
+}
+
+char *apex_preprocess_quarto_shortcodes(const char *text, bool warn_unknown, bool unsafe) {
+    if (!text) {
+        return NULL;
+    }
+
+    size_t cap = strlen(text) * 2 + 256;
+    char *out = malloc(cap);
+    if (!out) {
+        return NULL;
+    }
+    size_t len = 0;
+    out[0] = '\0';
+    bool changed = false;
+
+    const char *read = text;
+    while (*read) {
+        if (!shortcode_in_fenced_code(text, read)) {
+            const char *sc = strstr(read, "{{");
+            if (sc) {
+                if (sc > read) {
+                    if (!append_chunk(&out, &len, &cap, read, (size_t)(sc - read))) {
+                        free(out);
+                        return NULL;
+                    }
+                }
+                const char *after = sc;
+                if (try_shortcode(sc, &after, &out, &len, &cap, &changed, warn_unknown, unsafe)) {
+                    read = after;
+                    continue;
+                }
+                if (!append_str(&out, &len, &cap, "{{")) {
+                    free(out);
+                    return NULL;
+                }
+                read = sc + 2;
+                continue;
+            }
+        }
+
+        const char *line_end = line_end_ptr(read);
+        size_t chunk_len = (size_t)(line_end - read);
+        if (*line_end == '\n') {
+            chunk_len++;
+        }
+        if (!append_chunk(&out, &len, &cap, read, chunk_len)) {
+            free(out);
+            return NULL;
+        }
+        read += chunk_len;
+    }
+
+    if (!changed) {
+        free(out);
+        return NULL;
+    }
+    return out;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Quarto/Pandoc shortcode shim ({{< ... >}}, {{% ... %}})
+ */
+
+#ifndef APEX_QUARTO_SHORTCODES_H
+#define APEX_QUARTO_SHORTCODES_H
+
+#include <stdbool.h>
+
+/**
+ * Convert known Quarto shortcodes to Apex/plugin syntax:
+ *   pagebreak -> {::pagebreak /}
+ *   kbd       -> {% kbd ... %}
+ *   include   -> <<[path]>
+ * Unknown shortcodes are left unchanged; when warn_unknown is true, a message
+ * is written to stderr. Pagebreak shortcodes emit raw HTML when unsafe is true.
+ * Returns NULL if unchanged.
+ */
+char *apex_preprocess_quarto_shortcodes(const char *text, bool warn_unknown, bool unsafe);
+
+#endif /* APEX_QUARTO_SHORTCODES_H */