apex-ruby 1.0.18 → 1.0.20

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

@@ -0,0 +1,351 @@
+/**
+ * Pandoc/Quarto raw content ({=format}) preprocessing
+ */
+
+#include "raw_content.h"
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+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 bool parse_raw_format(const char *start, const char *end,
+                             char *format_buf, size_t format_buf_size) {
+    if (!start || !end || end <= start || !format_buf || format_buf_size == 0) {
+        return false;
+    }
+
+    const char *p = start;
+    while (p < end && isspace((unsigned char)*p)) {
+        p++;
+    }
+    if (p >= end) {
+        return false;
+    }
+
+    const char *fmt_start = NULL;
+    const char *fmt_end = NULL;
+
+    if (*p == '{') {
+        p++;
+        if (p >= end || *p != '=') {
+            return false;
+        }
+        p++;
+        fmt_start = p;
+        while (p < end && (isalnum((unsigned char)*p) || *p == '_' || *p == '-')) {
+            p++;
+        }
+        fmt_end = p;
+        if (fmt_end == fmt_start || p >= end || *p != '}') {
+            return false;
+        }
+        p++;
+        while (p < end && isspace((unsigned char)*p)) {
+            p++;
+        }
+        if (p != end) {
+            return false;
+        }
+    } else if (*p == '=') {
+        p++;
+        fmt_start = p;
+        while (p < end && (isalnum((unsigned char)*p) || *p == '_' || *p == '-')) {
+            p++;
+        }
+        fmt_end = p;
+        if (fmt_end == fmt_start) {
+            return false;
+        }
+        while (p < end && isspace((unsigned char)*p)) {
+            p++;
+        }
+        if (p != end) {
+            return false;
+        }
+    } else {
+        return false;
+    }
+
+    size_t fmt_len = (size_t)(fmt_end - fmt_start);
+    if (fmt_len == 0 || fmt_len >= format_buf_size) {
+        return false;
+    }
+    for (size_t i = 0; i < fmt_len; i++) {
+        format_buf[i] = (char)tolower((unsigned char)fmt_start[i]);
+    }
+    format_buf[fmt_len] = '\0';
+    return true;
+}
+
+static bool is_html_format(const char *format) {
+    return format && strcasecmp(format, "html") == 0;
+}
+
+static bool emit_raw_block(char **out, size_t *len, size_t *cap,
+                           const char *body, size_t body_len,
+                           const char *format, bool unsafe) {
+    if (is_html_format(format) && unsafe) {
+        if (body_len > 0 && !append_chunk(out, len, cap, body, body_len)) {
+            return false;
+        }
+        if (body_len == 0 || body[body_len - 1] != '\n') {
+            if (!append_chunk(out, len, cap, "\n", 1)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    if (!append_str(out, len, cap, "<!-- raw format=")) {
+        return false;
+    }
+    if (!append_str(out, len, cap, format)) {
+        return false;
+    }
+    if (!append_str(out, len, cap, " -->\n")) {
+        return false;
+    }
+    if (body_len > 0 && !append_chunk(out, len, cap, body, body_len)) {
+        return false;
+    }
+    if (body_len == 0 || body[body_len - 1] != '\n') {
+        if (!append_chunk(out, len, cap, "\n", 1)) {
+            return false;
+        }
+    }
+    return append_str(out, len, cap, "<!-- /raw -->\n");
+}
+
+static bool emit_raw_inline(char **out, size_t *len, size_t *cap,
+                            const char *content, size_t content_len,
+                            const char *format, bool unsafe) {
+    if (is_html_format(format) && unsafe) {
+        return append_chunk(out, len, cap, content, content_len);
+    }
+
+    if (!append_str(out, len, cap, "<!-- raw format=")) {
+        return false;
+    }
+    if (!append_str(out, len, cap, format)) {
+        return false;
+    }
+    if (!append_str(out, len, cap, " -->")) {
+        return false;
+    }
+    if (!append_chunk(out, len, cap, content, content_len)) {
+        return false;
+    }
+    return append_str(out, len, cap, "<!-- /raw -->");
+}
+
+static const char *line_end_ptr(const char *p) {
+    const char *e = strchr(p, '\n');
+    return e ? e : p + strlen(p);
+}
+
+static bool try_raw_block_fence(const char *line_start, const char *line_end,
+                                const char **read_out, char **out, size_t *len, size_t *cap,
+                                bool unsafe, bool *changed) {
+    const char *content = line_start;
+    while (content < line_end && (*content == ' ' || *content == '\t')) {
+        content++;
+    }
+    if ((size_t)(line_end - content) < 3 || strncmp(content, "```", 3) != 0) {
+        return false;
+    }
+
+    int tick_count = 0;
+    const char *ticks = content;
+    while (ticks < line_end && *ticks == '`') {
+        tick_count++;
+        ticks++;
+    }
+    if (tick_count < 3) {
+        return false;
+    }
+    while (ticks < line_end && (*ticks == ' ' || *ticks == '\t')) {
+        ticks++;
+    }
+
+    char format[64];
+    if (!parse_raw_format(ticks, line_end, format, sizeof(format))) {
+        return false;
+    }
+
+    const char *body_start = (line_end < line_start + strlen(line_start) && *line_end == '\n')
+        ? line_end + 1 : line_end;
+    const char *scan = body_start;
+    while (*scan) {
+        const char *cl_start = scan;
+        const char *cl_end = line_end_ptr(scan);
+        const char *cl_content = cl_start;
+        while (cl_content < cl_end && (*cl_content == ' ' || *cl_content == '\t')) {
+            cl_content++;
+        }
+        int close_ticks = 0;
+        while (cl_content + close_ticks < cl_end && cl_content[close_ticks] == '`') {
+            close_ticks++;
+        }
+        if (close_ticks >= tick_count) {
+            const char *after_ticks = cl_content + close_ticks;
+            while (after_ticks < cl_end && (*after_ticks == ' ' || *after_ticks == '\t')) {
+                after_ticks++;
+            }
+            if (after_ticks == cl_end) {
+                size_t body_len = (size_t)(cl_start - body_start);
+                if (!emit_raw_block(out, len, cap, body_start, body_len, format, unsafe)) {
+                    return false;
+                }
+                *changed = true;
+                *read_out = (*cl_end == '\n') ? cl_end + 1 : cl_end;
+                return true;
+            }
+        }
+        scan = (*cl_end == '\n') ? cl_end + 1 : cl_end;
+    }
+
+    return false;
+}
+
+char *apex_preprocess_raw_content(const char *text, 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;
+    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 (!in_fenced_code && at_line_start) {
+            const char *after_block = read;
+            if (try_raw_block_fence(line_start, line_end, &after_block, &out, &len, &cap, unsafe, &changed)) {
+                read = after_block;
+                continue;
+            }
+        }
+
+        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 && *read == '`') {
+            int tick_count = 0;
+            const char *tick_start = read;
+            while (read[tick_count] == '`') {
+                tick_count++;
+            }
+            if (tick_count > 0) {
+                const char *content_start = tick_start + tick_count;
+                const char *content_end = content_start;
+                while (*content_end) {
+                    if (*content_end == '`') {
+                        int close_ticks = 0;
+                        while (content_end[close_ticks] == '`') {
+                            close_ticks++;
+                        }
+                        if (close_ticks == tick_count) {
+                            break;
+                        }
+                    }
+                    content_end++;
+                }
+
+                if (*content_end == '`') {
+                    const char *after_ticks = content_end + tick_count;
+                    const char *fmt_scan = after_ticks;
+                    while (*fmt_scan == ' ' || *fmt_scan == '\t') {
+                        fmt_scan++;
+                    }
+
+                    const char *fmt_end = fmt_scan;
+                    if (*fmt_scan == '{') {
+                        fmt_end = strchr(fmt_scan, '}');
+                        if (fmt_end) {
+                            fmt_end++;
+                        } else {
+                            fmt_end = fmt_scan;
+                        }
+                    } else if (*fmt_scan == '=') {
+                        fmt_end = fmt_scan + 1;
+                        while (*fmt_end && (isalnum((unsigned char)*fmt_end) || *fmt_end == '_' || *fmt_end == '-')) {
+                            fmt_end++;
+                        }
+                    }
+
+                    char format[64];
+                    if (parse_raw_format(fmt_scan, fmt_end, format, sizeof(format))) {
+                        size_t content_len = (size_t)(content_end - content_start);
+                        if (!emit_raw_inline(&out, &len, &cap, content_start, content_len, format, unsafe)) {
+                            free(out);
+                            return NULL;
+                        }
+                        changed = true;
+                        read = fmt_end;
+                        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/raw_content.h

@@ -0,0 +1,20 @@
+/**
+ * Pandoc/Quarto raw content ({=format}) preprocessing
+ */
+
+#ifndef APEX_RAW_CONTENT_H
+#define APEX_RAW_CONTENT_H
+
+#include <stdbool.h>
+
+/**
+ * Convert Pandoc/Quarto raw content blocks and inline spans.
+ *
+ * Block: ```{=html} ... ```  -> raw HTML (when unsafe) or HTML comment wrapper
+ * Inline: `code`{=html}      -> raw HTML inline (when unsafe)
+ *
+ * Returns newly allocated text, or NULL when no changes were made.
+ */
+char *apex_preprocess_raw_content(const char *text, bool unsafe);
+
+#endif /* APEX_RAW_CONTENT_H */

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

@@ -91,6 +91,64 @@ static bool is_blank_line(const char *line, size_t len) {
     return true;
 }
 
+/*
+ * Detect a fenced code marker line (` ``` ` or `~~~`) with up to 3 leading spaces.
+ * Returns true and fills fence_char/fence_len when a marker is present.
+ */
+static bool parse_fence_marker(const char *line, size_t len, char *fence_char, int *fence_len) {
+    if (!line || len == 0 || !fence_char || !fence_len) return false;
+
+    size_t i = 0;
+    int indent = 0;
+    while (i < len && line[i] == ' ' && indent < 4) {
+        i++;
+        indent++;
+    }
+    if (indent > 3 || i >= len) return false;
+
+    char c = line[i];
+    if (c != '`' && c != '~') return false;
+
+    size_t j = i;
+    while (j < len && line[j] == c) {
+        j++;
+    }
+    int run = (int)(j - i);
+    if (run < 3) return false;
+
+    *fence_char = c;
+    *fence_len = run;
+    return true;
+}
+
+/* Closing fence must be only fence chars followed by optional spaces/tabs. */
+static bool is_closing_fence(const char *line, size_t len, char fence_char, int fence_len) {
+    if (!line || len == 0 || !fence_char || fence_len < 3) return false;
+
+    size_t i = 0;
+    int indent = 0;
+    while (i < len && line[i] == ' ' && indent < 4) {
+        i++;
+        indent++;
+    }
+    if (indent > 3 || i >= len || line[i] != fence_char) return false;
+
+    size_t j = i;
+    while (j < len && line[j] == fence_char) {
+        j++;
+    }
+    if ((int)(j - i) < fence_len) return false;
+
+    while (j < len) {
+        if (line[j] != ' ' && line[j] != '\t') {
+            return false;
+        }
+        j++;
+    }
+
+    return true;
+}
+
 /**
  * Check if a line is a horizontal rule (--- on a line by itself)
  */
@@ -290,6 +348,9 @@ static char *apex_process_relaxed_tables_impl(const char *text,
     char *write = output;
     size_t remaining = output_capacity;
     size_t output_len = 0;
+    bool in_fenced_code = false;
+    char fenced_char = 0;
+    int fenced_len = 0;
 
     /* Track potential table rows */
     typedef struct {
@@ -316,6 +377,59 @@ static char *apex_process_relaxed_tables_impl(const char *text,
 
         size_t line_len = line_end - line_start;
         bool has_newline = (*line_end == '\n');
+        char marker_char = 0;
+        int marker_len = 0;
+        bool has_fence_marker = parse_fence_marker(line_start, line_len, &marker_char, &marker_len);
+
+        if (!in_fenced_code && has_fence_marker) {
+            in_fenced_code = true;
+            fenced_char = marker_char;
+            fenced_len = marker_len;
+        } else if (in_fenced_code && is_closing_fence(line_start, line_len, fenced_char, fenced_len)) {
+            in_fenced_code = false;
+            fenced_char = 0;
+            fenced_len = 0;
+        }
+
+        /* Skip grid tables (lines starting with +) so relaxed table detection
+         * does not treat grid borders as pipe table rows. */
+        if (!in_fenced_code) {
+            const char *line_check = line_start;
+            while (line_check < line_end && (*line_check == ' ' || *line_check == '\t')) {
+                line_check++;
+            }
+            if (line_check < line_end && *line_check == '+') {
+                if (rows_count > 0) {
+                    for (size_t i = 0; i < rows_count; i++) {
+                        if (rows[i].len < remaining) {
+                            memcpy(write, rows[i].start, rows[i].len);
+                            write += rows[i].len;
+                            remaining -= rows[i].len;
+                            output_len += rows[i].len;
+                            if (has_newline && remaining > 0) {
+                                *write++ = '\n';
+                                remaining--;
+                                output_len++;
+                            }
+                        }
+                    }
+                    rows_count = 0;
+                }
+                if (line_len < remaining) {
+                    memcpy(write, line_start, line_len);
+                    write += line_len;
+                    remaining -= line_len;
+                    output_len += line_len;
+                    if (has_newline && remaining > 0) {
+                        *write++ = '\n';
+                        remaining--;
+                        output_len++;
+                    }
+                }
+                read = has_newline ? line_end + 1 : line_end;
+                continue;
+            }
+        }
 
         /* Check if this is a blank line */
         if (is_blank_line(line_start, line_len)) {
@@ -455,7 +569,7 @@ static char *apex_process_relaxed_tables_impl(const char *text,
         }
 
         /* Check if this is a separator row */
-        if (is_separator_row(line_start, line_len)) {
+        if (!in_fenced_code && is_separator_row(line_start, line_len)) {
             /* Separator row: if we have accumulated rows, write them as-is */
             if (rows_count > 0) {
                 for (size_t i = 0; i < rows_count; i++) {
@@ -637,7 +751,7 @@ static char *apex_process_relaxed_tables_impl(const char *text,
         bool starts_with_pipe = (p < line_end && *p == '|');
 
         /* Check if this is a separator row - if so, skip relaxed table processing for previous rows */
-        if (is_separator_row(line_start, line_len)) {
+        if (!in_fenced_code && is_separator_row(line_start, line_len)) {
             /* Separator row found - if we have accumulated rows, they're already a valid table */
             /* Write them as-is and reset */
             if (rows_count > 0) {
@@ -724,7 +838,7 @@ static char *apex_process_relaxed_tables_impl(const char *text,
         }
 
         /* Process rows with or without leading pipes - both need separators if missing */
-        int columns = count_columns(line_start, line_len);
+        int columns = in_fenced_code ? -1 : count_columns(line_start, line_len);
         if (columns > 0) {
             /* Potential table row - add to accumulator */
             if (rows_count == 0) {

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

@@ -10,6 +10,30 @@
 #include <ctype.h>
 #include <stdbool.h>
 
+/** True if content at p looks like a list marker (- , * , + , or digit+. ) */
+static int looks_like_list_marker(const char *p) {
+    if (!*p) return 0;
+    if (*p == '-' || *p == '*' || *p == '+')
+        return (p[1] == ' ' || p[1] == '\t');
+    if (isdigit((unsigned char)*p)) {
+        while (isdigit((unsigned char)*p)) p++;
+        return (*p == '.' && (p[1] == ' ' || p[1] == '\t'));
+    }
+    return 0;
+}
+
+/** True if we're at the start of a line that is an indented code block (4+ spaces or tab). */
+static int line_is_indented_code_block(const char *read) {
+    if (!*read) return 0;
+    if (*read == '\t')
+        return !looks_like_list_marker(read + 1);
+    if (read[0] != ' ' || read[1] != ' ' || read[2] != ' ' || read[3] != ' ')
+        return 0;
+    const char *content = read + 4;
+    while (*content == ' ') content++;
+    return *content && !looks_like_list_marker(content);
+}
+
 /**
  * Process special markers in text
  */
@@ -26,7 +50,36 @@ char *apex_process_special_markers(const char *text) {
     char *write = output;
     size_t remaining = capacity;
 
+    bool in_code_block = false;
+    bool in_inline_code = false;
+    bool in_indented_code_block = false;
+
     while (*read) {
+        /* At line start: indented code block only if 4+ spaces/tab and not a list line */
+        if (read == text || read[-1] == '\n') {
+            in_indented_code_block = line_is_indented_code_block(read);
+        }
+
+        /* Track fenced code blocks (```) and inline code (`) */
+        if (*read == '`') {
+            if (read[1] == '`' && read[2] == '`') {
+                in_code_block = !in_code_block;
+            } else if (!in_code_block) {
+                in_inline_code = !in_inline_code;
+            }
+        }
+
+        /* Skip special marker processing inside any code context */
+        if (in_code_block || in_inline_code || in_indented_code_block) {
+            if (remaining > 0) {
+                *write++ = *read++;
+                remaining--;
+            } else {
+                read++;
+            }
+            continue;
+        }
+
         /* Check for End of Block marker (Kramdown) */
         /* Pattern: ^ on a line by itself (with optional leading whitespace) */
         if (*read == '^') {

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

@@ -443,8 +443,30 @@ char *apex_apply_syntax_highlighting(const char *html, const char *tool, bool li
                 continue;
             }
 
+            /* Per-block line numbers from Quarto/Pandoc fence attr markers */
+            bool block_line_numbers = line_numbers;
+            if (!block_line_numbers && pre_start > html) {
+                size_t lookback = (size_t)(pre_start - html);
+                if (lookback > 512) {
+                    lookback = 512;
+                }
+                const char *region_start = pre_start - lookback;
+                char region_buf[513];
+                memcpy(region_buf, region_start, lookback);
+                region_buf[lookback] = '\0';
+                if (strstr(region_buf, "data-linenos=\"true\"")) {
+                    block_line_numbers = true;
+                }
+            }
+            if (!block_line_numbers) {
+                const char *linenos_attr = strstr(pre_start, "data-linenos=\"true\"");
+                if (linenos_attr && linenos_attr < pre_tag_end) {
+                    block_line_numbers = true;
+                }
+            }
+
             /* Run syntax highlighter */
-            char *highlighted = highlight_code_block(code, language, tool, line_numbers, ansi_output, theme);
+            char *highlighted = highlight_code_block(code, language, tool, block_line_numbers, ansi_output, theme);
             free(code);
 
             if (highlighted && *highlighted) {