apex-ruby 1.0.6

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

@@ -0,0 +1,93 @@
+/**
+ * @file buffer.c
+ * @brief Dynamic buffer implementation
+ */
+
+#include "apex/buffer.h"
+#include <stdlib.h>
+#include <string.h>
+
+#define BUFFER_INIT_CAPACITY 256
+#define BUFFER_GROWTH_FACTOR 2
+
+void apex_buffer_init(apex_buffer *buf, size_t initial_capacity) {
+    if (initial_capacity == 0) {
+        initial_capacity = BUFFER_INIT_CAPACITY;
+    }
+
+    buf->data = (char *)malloc(initial_capacity);
+    buf->size = 0;
+    buf->capacity = initial_capacity;
+
+    if (buf->data) {
+        buf->data[0] = '\0';
+    }
+}
+
+void apex_buffer_free(apex_buffer *buf) {
+    if (buf && buf->data) {
+        free(buf->data);
+        buf->data = NULL;
+        buf->size = 0;
+        buf->capacity = 0;
+    }
+}
+
+void apex_buffer_clear(apex_buffer *buf) {
+    buf->size = 0;
+    if (buf->data) {
+        buf->data[0] = '\0';
+    }
+}
+
+static void apex_buffer_grow(apex_buffer *buf, size_t needed) {
+    size_t new_capacity = buf->capacity;
+
+    while (new_capacity < needed) {
+        new_capacity *= BUFFER_GROWTH_FACTOR;
+    }
+
+    char *new_data = (char *)realloc(buf->data, new_capacity);
+    if (new_data) {
+        buf->data = new_data;
+        buf->capacity = new_capacity;
+    }
+}
+
+void apex_buffer_append(apex_buffer *buf, const char *data, size_t len) {
+    if (!buf || !data || len == 0) {
+        return;
+    }
+
+    size_t needed = buf->size + len + 1;
+    if (needed > buf->capacity) {
+        apex_buffer_grow(buf, needed);
+    }
+
+    memcpy(buf->data + buf->size, data, len);
+    buf->size += len;
+    buf->data[buf->size] = '\0';
+}
+
+void apex_buffer_append_str(apex_buffer *buf, const char *str) {
+    if (str) {
+        apex_buffer_append(buf, str, strlen(str));
+    }
+}
+
+void apex_buffer_append_char(apex_buffer *buf, char c) {
+    apex_buffer_append(buf, &c, 1);
+}
+
+const char *apex_buffer_cstr(const apex_buffer *buf) {
+    return buf ? buf->data : "";
+}
+
+char *apex_buffer_detach(apex_buffer *buf) {
+    char *result = buf->data;
+    buf->data = NULL;
+    buf->size = 0;
+    buf->capacity = 0;
+    return result;
+}
+

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

@@ -0,0 +1,362 @@
+/**
+ * Abbreviations Extension for Apex
+ * Implementation
+ */
+
+#include "abbreviations.h"
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+/**
+ * Free abbreviations list
+ */
+void apex_free_abbreviations(abbr_item *abbrs) {
+    while (abbrs) {
+        abbr_item *next = abbrs->next;
+        free(abbrs->abbr);
+        free(abbrs->expansion);
+        free(abbrs);
+        abbrs = next;
+    }
+}
+
+/**
+ * Trim whitespace
+ */
+static char *trim(char *str) {
+    while (isspace((unsigned char)*str)) str++;
+    char *end = str + strlen(str) - 1;
+    while (end > str && isspace((unsigned char)*end)) *end-- = '\0';
+    return str;
+}
+
+/**
+ * Process MMD 6 inline abbreviations in text (before parsing)
+ * Pattern: [>(abbr) expansion] → abbr (with definition added)
+ */
+static char *process_inline_abbreviations(const char *text, abbr_item **abbrs_list) {
+    if (!text) return NULL;
+
+    size_t len = strlen(text);
+    char *output = malloc(len * 2);  /* Room for expansion */
+    if (!output) return strdup(text);
+
+    const char *read = text;
+    char *write = output;
+
+    while (*read) {
+        /* Check for [>(abbr) expansion] */
+        if (strncmp(read, "[>(", 3) == 0) {
+            const char *abbr_start = read + 3;
+            const char *abbr_end = strchr(abbr_start, ')');
+
+            if (abbr_end) {
+                const char *exp_start = abbr_end + 1;
+                while (*exp_start == ' ') exp_start++;
+                const char *exp_end = strchr(exp_start, ']');
+
+                if (exp_end) {
+                    /* Extract abbreviation and expansion */
+                    int abbr_len = abbr_end - abbr_start;
+                    int exp_len = exp_end - exp_start;
+
+                    if (abbr_len > 0 && abbr_len < 256 && exp_len > 0 && exp_len < 1024) {
+                        char abbr_text[256], exp_text[1024];
+                        memcpy(abbr_text, abbr_start, abbr_len);
+                        abbr_text[abbr_len] = '\0';
+                        memcpy(exp_text, exp_start, exp_len);
+                        exp_text[exp_len] = '\0';
+
+                        /* Add to abbreviations list */
+                        abbr_item *item = malloc(sizeof(abbr_item));
+                        if (item) {
+                            item->abbr = strdup(trim(abbr_text));
+                            item->expansion = strdup(trim(exp_text));
+                            item->next = *abbrs_list;
+                            *abbrs_list = item;
+                        }
+
+                        /* Write just the abbreviation text */
+                        strcpy(write, abbr_text);
+                        write += abbr_len;
+                        read = exp_end + 1;
+                        continue;
+                    }
+                }
+            }
+        }
+
+        /* Regular character */
+        *write++ = *read++;
+    }
+
+    *write = '\0';
+    return output;
+}
+
+/**
+ * Extract abbreviations from text
+ * Pattern: *[abbr]: expansion or [>abbr]: expansion
+ */
+abbr_item *apex_extract_abbreviations(char **text_ptr) {
+    if (!text_ptr || !*text_ptr) return NULL;
+
+    char *text = *text_ptr;
+    abbr_item *abbrs = NULL;
+    abbr_item **tail = &abbrs;
+    
+
+    /* First, process inline abbreviations [>(abbr) expansion] */
+    char *processed = process_inline_abbreviations(text, &abbrs);
+    if (processed) {
+        strcpy(text, processed);
+        free(processed);
+    }
+
+    char *line_start = text;
+    char *line_end;
+    char *output = malloc(strlen(text) + 1);
+    char *output_write = output;
+
+    if (!output) return NULL;
+
+    while ((line_end = strchr(line_start, '\n')) != NULL || *line_start) {
+        if (!line_end) line_end = line_start + strlen(line_start);
+
+        size_t line_len = line_end - line_start;
+        char line[1024];
+        if (line_len >= sizeof(line)) line_len = sizeof(line) - 1;
+        memcpy(line, line_start, line_len);
+        line[line_len] = '\0';
+
+        /* Check for *[abbr]: expansion pattern (old MMD) */
+        if (line[0] == '*' && line[1] == '[') {
+            char *close_bracket = strchr(line + 2, ']');
+            if (close_bracket && close_bracket[1] == ':') {
+                /* Found abbreviation definition */
+                *close_bracket = '\0';
+                char *abbr = trim(line + 2);
+                char *expansion = trim(close_bracket + 2);
+
+                if (*abbr && *expansion) {
+                    abbr_item *item = malloc(sizeof(abbr_item));
+                    if (item) {
+                        item->abbr = strdup(abbr);
+                        item->expansion = strdup(expansion);
+                        item->next = NULL;
+
+                        *tail = item;
+                        tail = &item->next;
+                    }
+                }
+
+                /* Skip this line in output */
+                line_start = *line_end ? line_end + 1 : line_end;
+                continue;
+            }
+        }
+
+        /* Check for [>abbr]: expansion pattern (MMD 6) */
+        if (line[0] == '[' && line[1] == '>') {
+            char *close_bracket = strchr(line + 2, ']');
+            if (close_bracket && close_bracket[1] == ':') {
+                /* Found MMD 6 abbreviation definition */
+                *close_bracket = '\0';
+                char *abbr = trim(line + 2);
+                char *expansion = trim(close_bracket + 2);
+
+                if (*abbr && *expansion) {
+                    abbr_item *item = malloc(sizeof(abbr_item));
+                    if (item) {
+                        item->abbr = strdup(abbr);
+                        item->expansion = strdup(expansion);
+                        item->next = NULL;
+
+                        *tail = item;
+                        tail = &item->next;
+                    }
+                }
+
+                /* Skip this line in output */
+                line_start = *line_end ? line_end + 1 : line_end;
+                continue;
+            }
+        }
+
+        /* Not an abbreviation, copy line to output */
+        memcpy(output_write, line_start, line_len);
+        output_write += line_len;
+        if (*line_end) {
+            *output_write++ = '\n';
+            line_start = line_end + 1;
+        } else {
+            break;
+        }
+    }
+
+    *output_write = '\0';
+
+    /* Update text pointer to cleaned text */
+    strcpy(text, output);
+    free(output);
+
+    return abbrs;
+}
+
+/**
+ * Replace abbreviations in HTML
+ */
+char *apex_replace_abbreviations(const char *html, abbr_item *abbrs) {
+    if (!html || !abbrs) {
+        return html ? strdup(html) : NULL;
+    }
+
+    size_t html_len = strlen(html);
+    /* Calculate max possible expansion:
+     * Each abbreviation could be replaced with <abbr title="expansion">abbr</abbr>
+     * Worst case: very long expansions. Use html_len * 5 to be safe. */
+    size_t capacity = html_len * 5;
+    char *output = malloc(capacity);
+    if (!output) return strdup(html);
+
+    const char *read = html;
+    char *write = output;
+    size_t remaining = capacity;
+
+    while (*read) {
+        bool replaced = false;
+
+        /* Check for MMD 6 inline abbreviation (HTML-escaped): [&gt;abbr] or [&gt;(abbr) expansion] */
+        if (strncmp(read, "[&gt;", 5) == 0) {
+            const char *start = read + 5;
+            const char *end = start;
+
+            /* Find closing ] */
+            while (*end && *end != ']' && *end != '\n' && *end != '<') end++;
+
+            if (*end == ']') {
+                /* Check for inline expansion: [&gt;(abbr) expansion] */
+                if (*start == '(') {
+                    const char *abbr_end = strchr(start + 1, ')');
+                    if (abbr_end && abbr_end < end) {
+                        /* Extract abbreviation and expansion */
+                        int abbr_len = abbr_end - (start + 1);
+                        int exp_len = end - (abbr_end + 1);
+
+                        if (abbr_len > 0 && exp_len > 0) {
+                            char abbr_text[256];
+                            char exp_text[1024];
+
+                            memcpy(abbr_text, start + 1, abbr_len);
+                            abbr_text[abbr_len] = '\0';
+
+                            memcpy(exp_text, abbr_end + 1, exp_len);
+                            exp_text[exp_len] = '\0';
+
+                            /* Trim whitespace */
+                            char *abbr_trimmed = trim(abbr_text);
+                            char *exp_trimmed = trim(exp_text);
+
+                            /* Generate abbr tag */
+                            char abbr_tag[2048];
+                            snprintf(abbr_tag, sizeof(abbr_tag),
+                                    "<abbr title=\"%s\">%s</abbr>",
+                                    exp_trimmed, abbr_trimmed);
+
+                            size_t tag_len = strlen(abbr_tag);
+                            if (tag_len < remaining) {
+                                memcpy(write, abbr_tag, tag_len);
+                                write += tag_len;
+                                remaining -= tag_len;
+                            }
+
+                            read = end + 1;
+                            replaced = true;
+                        }
+                    }
+                } else {
+                    /* Reference abbreviation: [&gt;MMD] */
+                    int ref_len = end - start;
+                    if (ref_len > 0 && ref_len < 256) {
+                        char ref[256];
+                        memcpy(ref, start, ref_len);
+                        ref[ref_len] = '\0';
+                        char *ref_trimmed = trim(ref);
+
+                        /* Look up in abbreviation list */
+                        for (abbr_item *item = abbrs; item; item = item->next) {
+                            if (strcmp(item->abbr, ref_trimmed) == 0) {
+                                /* Found match */
+                                char abbr_tag[2048];
+                                snprintf(abbr_tag, sizeof(abbr_tag),
+                                        "<abbr title=\"%s\">%s</abbr>",
+                                        item->expansion, item->abbr);
+
+                                size_t tag_len = strlen(abbr_tag);
+                                if (tag_len < remaining) {
+                                    memcpy(write, abbr_tag, tag_len);
+                                    write += tag_len;
+                                    remaining -= tag_len;
+                                }
+
+                                read = end + 1;
+                                replaced = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                if (replaced) continue;
+            }
+        }
+
+        /* Try each abbreviation (automatic replacement) */
+        for (abbr_item *item = abbrs; item; item = item->next) {
+            size_t abbr_len = strlen(item->abbr);
+
+            /* Check if we have a match */
+            if (strncmp(read, item->abbr, abbr_len) == 0) {
+                /* Check it's a whole word (not part of larger word) */
+                bool word_boundary = true;
+                if (read > html && isalnum((unsigned char)*(read - 1))) word_boundary = false;
+                if (isalnum((unsigned char)read[abbr_len])) word_boundary = false;
+
+                if (word_boundary) {
+                    /* Replace with <abbr> tag */
+                    char abbr_tag[2048];
+                    snprintf(abbr_tag, sizeof(abbr_tag),
+                            "<abbr title=\"%s\">%s</abbr>",
+                            item->expansion, item->abbr);
+
+                    size_t tag_len = strlen(abbr_tag);
+                    if (tag_len < remaining) {
+                        memcpy(write, abbr_tag, tag_len);
+                        write += tag_len;
+                        remaining -= tag_len;
+                    }
+
+                    read += abbr_len;
+                    replaced = true;
+                    break;
+                }
+            }
+        }
+
+        if (!replaced) {
+            if (remaining > 0) {
+                *write++ = *read++;
+                remaining--;
+            } else {
+                read++;
+            }
+        }
+    }
+
+    *write = '\0';
+    return output;
+}
+

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

@@ -0,0 +1,45 @@
+/**
+ * Abbreviations Extension for Apex
+ *
+ * Supports Kramdown/MMD abbreviation syntax:
+ * *[HTML]: HyperText Markup Language
+ * *[CSS]: Cascading Style Sheets
+ *
+ * Then HTML and CSS in the text are wrapped in <abbr> tags
+ */
+
+#ifndef APEX_ABBREVIATIONS_H
+#define APEX_ABBREVIATIONS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct abbr_item {
+    char *abbr;
+    char *expansion;
+    struct abbr_item *next;
+} abbr_item;
+
+/**
+ * Extract abbreviation definitions from text
+ * Modifies text_ptr to skip abbreviation definitions
+ */
+abbr_item *apex_extract_abbreviations(char **text_ptr);
+
+/**
+ * Replace abbreviations in HTML with <abbr> tags
+ */
+char *apex_replace_abbreviations(const char *html, abbr_item *abbrs);
+
+/**
+ * Free abbreviation list
+ */
+void apex_free_abbreviations(abbr_item *abbrs);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APEX_ABBREVIATIONS_H */
+

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

@@ -0,0 +1,184 @@
+/**
+ * Advanced Footnotes Extension for Apex
+ * Implementation
+ *
+ * Extends cmark-gfm's footnote system to support block-level Markdown
+ * content in footnote definitions.
+ */
+
+#include "advanced_footnotes.h"
+#include "parser.h"
+#include "node.h"
+#include "inlines.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+/**
+ * Check if a footnote definition has block-level content
+ * (multiple paragraphs, code blocks, lists, etc.)
+ */
+static bool has_block_content(const char *content) {
+    if (!content) return false;
+
+    /* Check for multiple paragraphs (blank lines) */
+    const char *p = content;
+    bool found_text = false;
+    bool found_blank = false;
+
+    while (*p) {
+        if (*p == '\n') {
+            if (p[1] == '\n' || (p[1] == '\r' && p[2] == '\n')) {
+                /* Blank line */
+                if (found_text) {
+                    found_blank = true;
+                }
+            }
+        } else if (!found_blank && *p != ' ' && *p != '\t' && *p != '\r') {
+            found_text = true;
+        } else if (found_blank && *p != ' ' && *p != '\t' && *p != '\r') {
+            /* Text after blank line - block content */
+            return true;
+        }
+        p++;
+    }
+
+    /* Check for code blocks (4+ spaces indent) */
+    p = content;
+    while (*p) {
+        if (*p == '\n' && p[1] == ' ' && p[2] == ' ' && p[3] == ' ' && p[4] == ' ') {
+            return true;
+        }
+        p++;
+    }
+
+    /* Check for fenced code blocks */
+    if (strstr(content, "```") || strstr(content, "~~~")) {
+        return true;
+    }
+
+    /* Check for lists */
+    p = content;
+    while (*p) {
+        if (*p == '\n' && (p[1] == '-' || p[1] == '*' || p[1] == '+' ||
+                           (p[1] >= '0' && p[1] <= '9'))) {
+            /* Potential list item */
+            const char *q = p + 2;
+            while (*q >= '0' && *q <= '9') q++;
+            if (*q == '.' || p[1] == '-' || p[1] == '*' || p[1] == '+') {
+                return true;
+            }
+        }
+        p++;
+    }
+
+    return false;
+}
+
+/**
+ * Re-parse footnote content as block-level Markdown
+ */
+static void reparse_footnote_blocks(cmark_node *footnote_def, cmark_parser *parser) {
+    (void)parser;
+    if (!footnote_def) return;
+
+    /* Get the footnote content */
+    cmark_node *first_child = cmark_node_first_child(footnote_def);
+    if (!first_child) return;
+
+    /* If it's already parsed as blocks, nothing to do */
+    cmark_node_type type = cmark_node_get_type(first_child);
+    if (type == CMARK_NODE_PARAGRAPH || type == CMARK_NODE_CODE_BLOCK ||
+        type == CMARK_NODE_LIST || type == CMARK_NODE_BLOCK_QUOTE) {
+        return; /* Already has block content */
+    }
+
+    /* Get text content */
+    const char *literal = cmark_node_get_literal(first_child);
+    if (!literal) return;
+
+    /* Check if it needs block parsing */
+    if (!has_block_content(literal)) return;
+
+    /* Create a new parser for the footnote content */
+    cmark_parser *sub_parser = cmark_parser_new(CMARK_OPT_FOOTNOTES);
+    if (!sub_parser) return;
+
+    /* Parse the content */
+    cmark_parser_feed(sub_parser, literal, strlen(literal));
+    cmark_node *parsed = cmark_parser_finish(sub_parser);
+
+    if (parsed) {
+        /* Remove old content */
+        while (first_child) {
+            cmark_node *next = cmark_node_next(first_child);
+            cmark_node_unlink(first_child);
+            cmark_node_free(first_child);
+            first_child = next;
+        }
+
+        /* Add parsed blocks */
+        cmark_node *child = cmark_node_first_child(parsed);
+        while (child) {
+            cmark_node *next = cmark_node_next(child);
+            cmark_node_unlink(child);
+            cmark_node_append_child(footnote_def, child);
+            child = next;
+        }
+
+        cmark_node_free(parsed);
+    }
+
+    cmark_parser_free(sub_parser);
+}
+
+/**
+ * Post-process footnotes to support block-level content
+ */
+cmark_node *apex_process_advanced_footnotes(cmark_node *root, cmark_parser *parser) {
+    if (!root) return root;
+
+    cmark_iter *iter = cmark_iter_new(root);
+    cmark_event_type ev_type;
+    cmark_node *cur;
+
+    while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+        cur = cmark_iter_get_node(iter);
+
+        if (ev_type == CMARK_EVENT_ENTER) {
+            cmark_node_type type = cmark_node_get_type(cur);
+
+            /* Check if this is a footnote definition */
+            if (type == CMARK_NODE_FOOTNOTE_DEFINITION) {
+                reparse_footnote_blocks(cur, parser);
+            }
+        }
+    }
+
+    cmark_iter_free(iter);
+    return root;
+}
+
+/**
+ * Postprocess function for the extension
+ */
+static cmark_node *postprocess(cmark_syntax_extension *ext,
+                               cmark_parser *parser,
+                               cmark_node *root) {
+    (void)ext;
+    return apex_process_advanced_footnotes(root, parser);
+}
+
+/**
+ * Create advanced footnotes extension
+ */
+cmark_syntax_extension *create_advanced_footnotes_extension(void) {
+    cmark_syntax_extension *ext = cmark_syntax_extension_new("advanced_footnotes");
+    if (!ext) return NULL;
+
+    /* Set postprocess callback */
+    cmark_syntax_extension_set_postprocess_func(ext, postprocess);
+
+    return ext;
+}
+