apex-ruby 1.0.6

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

@@ -0,0 +1,248 @@
+/**
+ * Insert Extension
+ * Converts ++text++ to <ins>text</ins>
+ * Supports IAL attributes: ++text++{: .class} → <ins markdown="span" class="class">text</ins>
+ */
+
+#include "insert.h"
+#include "ial.h"  /* For parse_ial_content and attributes_to_html */
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <ctype.h>
+
+/**
+ * Find IAL pattern after text
+ * Returns pointer to IAL start, or NULL if not found
+ * Sets ial_end to end of IAL pattern
+ */
+static const char *find_ial_after(const char *text, const char **ial_end) {
+    const char *p = text;
+
+    /* Skip whitespace */
+    while (*p && (*p == ' ' || *p == '\t')) {
+        p++;
+    }
+
+    /* Check for IAL pattern { ... } */
+    if (*p == '{') {
+        const char *start = p;
+        p++;
+
+        /* Find closing } */
+        const char *close = strchr(p, '}');
+        if (close) {
+            *ial_end = close + 1;
+            return start;
+        }
+    }
+
+    return NULL;
+}
+
+/**
+ * Process ++insert++ syntax as preprocessing
+ * Converts to <ins>text</ins> before parsing
+ * If followed by IAL, converts to <ins markdown="span" ...>text</ins>
+ */
+char *apex_process_inserts(const char *text) {
+    if (!text) return NULL;
+
+    size_t len = strlen(text);
+    size_t capacity = len * 2;  /* Room for <ins> tags */
+    char *output = malloc(capacity);
+    if (!output) return NULL;
+
+    const char *read = text;
+    char *write = output;
+    size_t remaining = capacity;
+
+    bool in_code_block = false;
+    bool in_inline_code = false;
+
+    while (*read) {
+        /* Track code blocks (skip processing inside them) */
+        if (*read == '`') {
+            if (read[1] == '`' && read[2] == '`') {
+                in_code_block = !in_code_block;
+            } else if (!in_code_block) {
+                in_inline_code = !in_inline_code;
+            }
+        }
+
+        /* Look for ++insert++ (not in code, not Critic Markup) */
+        /* Skip if preceded by { (Critic Markup) */
+        bool is_critic = (read > text && read[-1] == '{');
+
+        /* Check opening ++ requirements:
+         * - Exactly 2 + characters: read[0] == '+' && read[1] == '+'
+         * - Not preceded by + or { (or beginning of line)
+         * - Character after ++ is not + or }
+         * - Character after ++ is not whitespace or newline
+         */
+        bool preceded_by_plus = (read > text && read[-1] == '+');
+        bool preceded_by_brace = (read > text && read[-1] == '{');
+        bool followed_by_plus = (read[2] == '+');
+        bool followed_by_brace = (read[2] == '}');
+        bool is_valid_insert_start = (read[0] == '+' && read[1] == '+' &&
+                                     read[2] != '+' && !followed_by_brace &&
+                                     read[2] != '\0' && read[2] != '\n' &&
+                                     read[2] != '\r' && read[2] != ' ' && read[2] != '\t' &&
+                                     !preceded_by_plus && !preceded_by_brace && !followed_by_plus);
+
+        if (!in_code_block && !in_inline_code && !is_critic && is_valid_insert_start) {
+
+            /* Find closing ++ */
+            const char *close = read + 2;
+            while (*close && *close != '\n' && *close != '\r') {
+                if (close[0] == '+' && close[1] == '+') {
+                    /* Check closing ++ requirements:
+                     * - Character after closing ++ is not +
+                     * - Character before closing ++ is not space
+                     * - Character immediately before or after closing ++ is not +
+                     */
+                    bool closing_followed_by_plus = (close[2] == '+');
+                    bool closing_preceded_by_space = (close > read + 2 && (close[-1] == ' ' || close[-1] == '\t'));
+                    bool closing_preceded_by_plus = (close > read + 2 && close[-1] == '+');
+
+                    if (!closing_followed_by_plus && !closing_preceded_by_space &&
+                        !closing_preceded_by_plus) {
+                        break;
+                    }
+                }
+                close++;
+            }
+
+            if (*close && close[0] == '+' && close[1] == '+' && close[2] != '+') {
+                /* Found complete ++insert++ */
+                size_t content_len = close - (read + 2);
+
+                /* Ensure there's actual content (not just ++ on a line by itself) */
+                if (content_len > 0) {
+                    const char *after_close = close + 2;
+                    const char *ial_end = NULL;
+                    const char *ial_start = find_ial_after(after_close, &ial_end);
+
+                    if (ial_start) {
+                        /* Has IAL - convert to <ins markdown="span" ...>text</ins> */
+                        size_t ial_len = (ial_end - 1) - (ial_start + 1);  /* Content inside {} */
+
+                        /* Parse IAL attributes */
+                        apex_attributes *attrs = parse_ial_content(ial_start + 1, ial_len);
+
+                        if (attrs) {
+                            /* Build ins tag with attributes */
+                            char *attr_str = attributes_to_html(attrs);
+                            if (attr_str) {
+                                /* Calculate space needed */
+                                size_t ins_open_len = 30 + strlen(attr_str) + content_len + 20;
+                                if (remaining < ins_open_len) {
+                                    size_t written = write - output;
+                                    capacity = (written + ins_open_len + 1) * 2;
+                                    char *new_output = realloc(output, capacity);
+                                    if (!new_output) {
+                                        free(attr_str);
+                                        apex_free_attributes(attrs);
+                                        goto cleanup;
+                                    }
+                                    output = new_output;
+                                    write = output + written;
+                                    remaining = capacity - written;
+                                }
+
+                                /* Write <ins markdown="span" ...> */
+                                int written = snprintf(write, remaining, "<ins markdown=\"span\"%s>", attr_str);
+                                if (written > 0) {
+                                    if ((size_t)written >= remaining) {
+                                        /* String was truncated - need more space */
+                                        size_t current_written = write - output;
+                                        capacity = (current_written + written + 1) * 2;
+                                        char *new_output = realloc(output, capacity);
+                                        if (!new_output) {
+                                            free(attr_str);
+                                            apex_free_attributes(attrs);
+                                            goto cleanup;
+                                        }
+                                        output = new_output;
+                                        write = output + current_written;
+                                        remaining = capacity - current_written;
+                                        /* Retry with more space */
+                                        written = snprintf(write, remaining, "<ins markdown=\"span\"%s>", attr_str);
+                                    }
+                                    if (written > 0 && (size_t)written < remaining) {
+                                        write += written;
+                                        remaining -= written;
+                                    }
+                                }
+
+                                /* Write the content */
+                                if (content_len < remaining) {
+                                    memcpy(write, read + 2, content_len);
+                                    write += content_len;
+                                    remaining -= content_len;
+                                }
+
+                                /* Write </ins> */
+                                const char *close_tag = "</ins>";
+                                size_t tag_len = strlen(close_tag);
+                                if (tag_len < remaining) {
+                                    memcpy(write, close_tag, tag_len);
+                                    write += tag_len;
+                                    remaining -= tag_len;
+                                }
+
+                                /* Skip past the closing ++ and IAL */
+                                read = ial_end;
+                                free(attr_str);
+                                apex_free_attributes(attrs);
+                                continue;
+                            }
+                            apex_free_attributes(attrs);
+                        }
+                    }
+
+                    /* No IAL - write simple <ins>text</ins> */
+                    const char *open_tag = "<ins>";
+                    size_t tag_len = strlen(open_tag);
+                    if (tag_len < remaining) {
+                        memcpy(write, open_tag, tag_len);
+                        write += tag_len;
+                        remaining -= tag_len;
+                    }
+
+                    /* Copy inserted content */
+                    if (content_len < remaining) {
+                        memcpy(write, read + 2, content_len);
+                        write += content_len;
+                        remaining -= content_len;
+                    }
+
+                    /* Write </ins> */
+                    const char *close_tag = "</ins>";
+                    tag_len = strlen(close_tag);
+                    if (tag_len < remaining) {
+                        memcpy(write, close_tag, tag_len);
+                        write += tag_len;
+                        remaining -= tag_len;
+                    }
+
+                    /* Skip past the closing ++ */
+                    read = close + 2;
+                    continue;
+                }
+            }
+        }
+
+        /* Copy character */
+        if (remaining > 0) {
+            *write++ = *read++;
+            remaining--;
+        } else {
+            read++;
+        }
+    }
+
+cleanup:
+    *write = '\0';
+    return output;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Insert Extension
+ * Handles ++text++ syntax (converts to <ins>text</ins>)
+ * Supports IAL attributes: ++text++{: .class} → <ins markdown="span" class="class">text</ins>
+ */
+
+#ifndef APEX_INSERT_H
+#define APEX_INSERT_H
+
+/**
+ * Process ++insert++ syntax in text
+ * Converts ++text++ to <ins>text</ins>
+ * If followed by IAL, converts to <ins markdown="span" ...>text</ins>
+ * Does not interfere with CriticMarkup {++text++} syntax
+ */
+char *apex_process_inserts(const char *text);
+
+#endif

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

@@ -0,0 +1,279 @@
+/**
+ * Math Extension for Apex
+ *
+ * Simple implementation that detects math delimiters and outputs HTML
+ * for MathJax/KaTeX to process on the client side.
+ */
+
+#include "math.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "parser.h"
+#include "inlines.h"
+#include "html.h"
+
+/* Node type for math */
+extern cmark_node_type APEX_NODE_MATH;
+
+/**
+ * Scan for $...$ inline math
+ * Returns length if found, 0 otherwise
+ *
+ * Rules to avoid false positives:
+ * - Must have non-whitespace after opening $
+ * - Must have non-whitespace before closing $
+ * - No spaces immediately inside the delimiters
+ */
+static int scan_dollar_math(const char *input, int len, bool *is_display) {
+    if (len < 3) return 0;
+
+    /* Check for $$ (display math) */
+    if (input[0] == '$' && input[1] == '$') {
+        *is_display = true;
+        /* Find closing $$ */
+        for (int i = 2; i < len - 1; i++) {
+            if (input[i] == '$' && input[i + 1] == '$') {
+                return i + 2;
+            }
+        }
+        return 0;
+    }
+
+    /* Check for single $ (inline math) */
+    if (input[0] == '$') {
+        *is_display = false;
+
+        /* Next character must not be whitespace or $ (avoid false positives like "$5 and $10") */
+        if (len < 2 || input[1] == ' ' || input[1] == '\t' || input[1] == '\n' || input[1] == '$') {
+            return 0;
+        }
+
+        /* Find closing $ */
+        for (int i = 1; i < len; i++) {
+            if (input[i] == '$') {
+                /* Make sure it's not escaped */
+                if (i > 0 && input[i - 1] == '\\') continue;
+
+                /* Previous character should not be whitespace (avoid "$5 " matching) */
+                if (i > 1 && (input[i - 1] == ' ' || input[i - 1] == '\t' || input[i - 1] == '\n')) {
+                    return 0;
+                }
+
+                /* Must have at least one character of content */
+                if (i == 1) return 0;
+
+                return i + 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * Scan for \(...\) or \[...\] LaTeX-style math
+ * Returns length if found, 0 otherwise
+ */
+static int scan_latex_math(const char *input, int len, bool *is_display) {
+    if (len < 4) return 0;
+
+    /* Check for \[ (display math) */
+    if (input[0] == '\\' && input[1] == '[') {
+        *is_display = true;
+        /* Find closing \] */
+        for (int i = 2; i < len - 1; i++) {
+            if (input[i] == '\\' && input[i + 1] == ']') {
+                return i + 2;
+            }
+        }
+        return 0;
+    }
+
+    /* Check for \( (inline math) */
+    if (input[0] == '\\' && input[1] == '(') {
+        *is_display = false;
+        /* Find closing \) */
+        for (int i = 2; i < len - 1; i++) {
+            if (input[i] == '\\' && input[i + 1] == ')') {
+                /* Validate: math content should have at least one valid math character */
+                /* Math should contain letters, numbers, or common math operators */
+                /* Reject if content is empty or only contains non-math special characters */
+                int content_len = i - 2;
+                if (content_len <= 0) {
+                    return 0;
+                }
+
+                bool has_math_content = false;
+                for (int j = 2; j < i; j++) {
+                    unsigned char c = (unsigned char)input[j];
+                    /* Allow letters, numbers, common math operators, and whitespace */
+                    if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+                        (c >= '0' && c <= '9') || c == '+' || c == '-' || c == '*' ||
+                        c == '/' || c == '=' || c == '^' || c == '_' || c == ' ' ||
+                        c == '.' || c == ',' || c == '(' || c == ')' || c == '\\') {
+                        has_math_content = true;
+                        break;
+                    }
+                }
+                /* If no valid math content found, don't treat as math */
+                if (!has_math_content) {
+                    return 0;
+                }
+                return i + 2;
+            }
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * Match function for $ character
+ */
+static cmark_node *match_math_dollar(cmark_syntax_extension *self,
+                                      cmark_parser *parser,
+                                      cmark_node *parent,
+                                      unsigned char character,
+                                      cmark_inline_parser *inline_parser) {
+    (void)self;
+    (void)parent;
+    if (character != '$') return NULL;
+
+    /* Get current position and remaining input */
+    int pos = cmark_inline_parser_get_offset(inline_parser);
+    cmark_chunk *chunk = cmark_inline_parser_get_chunk(inline_parser);
+
+    if (pos >= chunk->len) return NULL;
+
+    const char *input = (const char *)chunk->data + pos;
+    int remaining = chunk->len - pos;
+
+    /* Check for math */
+    bool is_display = false;
+    int consumed = scan_dollar_math(input, remaining, &is_display);
+    if (consumed == 0) return NULL;
+
+    /* Extract math content */
+    int start_offset = is_display ? 2 : 1;
+    int end_offset = is_display ? 2 : 1;
+    int content_len = consumed - start_offset - end_offset;
+
+    if (content_len <= 0) return NULL;
+
+    /* Create HTML inline node with appropriate class */
+    cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_HTML_INLINE, parser->mem);
+
+    /* Build HTML string */
+    char *html = malloc(content_len + 100);
+    if (!html) return NULL;
+
+    if (is_display) {
+        snprintf(html, content_len + 100,
+                "<span class=\"math display\">\\[%.*s\\]</span>",
+                content_len, input + start_offset);
+    } else {
+        snprintf(html, content_len + 100,
+                "<span class=\"math inline\">\\(%.*s\\)</span>",
+                content_len, input + start_offset);
+    }
+
+    cmark_node_set_literal(node, html);
+    free(html);
+
+    /* Set line/column info */
+    node->start_line = node->end_line = cmark_inline_parser_get_line(inline_parser);
+    node->start_column = cmark_inline_parser_get_column(inline_parser) - 1;
+    node->end_column = cmark_inline_parser_get_column(inline_parser) + consumed - 1;
+
+    /* Advance parser */
+    cmark_inline_parser_set_offset(inline_parser, pos + consumed);
+
+    return node;
+}
+
+/**
+ * Match function for \ character (LaTeX style)
+ */
+__attribute__((unused))
+static cmark_node *match_math_backslash(cmark_syntax_extension *self,
+                                        cmark_parser *parser,
+                                        cmark_node *parent,
+                                        unsigned char character,
+                                        cmark_inline_parser *inline_parser) {
+    (void)self;
+    (void)parent;
+    if (character != '\\') return NULL;
+
+    /* Get current position and remaining input */
+    int pos = cmark_inline_parser_get_offset(inline_parser);
+    cmark_chunk *chunk = cmark_inline_parser_get_chunk(inline_parser);
+
+    if (pos >= chunk->len) return NULL;
+
+    const char *input = (const char *)chunk->data + pos;
+    int remaining = chunk->len - pos;
+
+    /* Check for math */
+    bool is_display = false;
+    int consumed = scan_latex_math(input, remaining, &is_display);
+    if (consumed == 0) return NULL;
+
+    /* Extract math content */
+    int start_offset = 2;  /* Skip \( or \[ */
+    int end_offset = 2;    /* Skip \) or \] */
+    int content_len = consumed - start_offset - end_offset;
+
+    if (content_len <= 0) return NULL;
+
+    /* Create HTML inline node */
+    cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_HTML_INLINE, parser->mem);
+
+    /* Build HTML string */
+    char *html = malloc(content_len + 100);
+    if (!html) return NULL;
+
+    if (is_display) {
+        snprintf(html, content_len + 100,
+                "<span class=\"math display\">\\[%.*s\\]</span>",
+                content_len, input + start_offset);
+    } else {
+        snprintf(html, content_len + 100,
+                "<span class=\"math inline\">\\(%.*s\\)</span>",
+                content_len, input + start_offset);
+    }
+
+    cmark_node_set_literal(node, html);
+    free(html);
+
+    /* Set line/column info */
+    node->start_line = node->end_line = cmark_inline_parser_get_line(inline_parser);
+    node->start_column = cmark_inline_parser_get_column(inline_parser) - 1;
+    node->end_column = cmark_inline_parser_get_column(inline_parser) + consumed - 1;
+
+    /* Advance parser */
+    cmark_inline_parser_set_offset(inline_parser, pos + consumed);
+
+    return node;
+}
+
+/**
+ * Create the math extension
+ */
+cmark_syntax_extension *create_math_extension(void) {
+    cmark_syntax_extension *ext = cmark_syntax_extension_new("math");
+
+    /* Register special characters $ and \ */
+    cmark_llist *special_chars = NULL;
+    cmark_mem *mem = cmark_get_default_mem_allocator();
+    special_chars = cmark_llist_append(mem, special_chars, (void *)'$');
+    special_chars = cmark_llist_append(mem, special_chars, (void *)'\\');
+    cmark_syntax_extension_set_special_inline_chars(ext, special_chars);
+
+    /* Set match function - it will handle both $ and \ */
+    cmark_syntax_extension_set_match_inline_func(ext, match_math_dollar);
+
+    return ext;
+}
+

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

@@ -0,0 +1,32 @@
+/**
+ * Math Extension for Apex
+ *
+ * Detects and preserves LaTeX math for client-side rendering:
+ * $inline math$
+ * $$display math$$
+ * \(inline\)
+ * \[display\]
+ */
+
+#ifndef APEX_MATH_H
+#define APEX_MATH_H
+
+#include <stdbool.h>
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Create and return the math extension
+ */
+cmark_syntax_extension *create_math_extension(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APEX_MATH_H */
+