apex-ruby 1.0.6

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

@@ -0,0 +1,60 @@
+/**
+ * Header ID Generation Extension
+ * Generates IDs for headers following GFM or MMD6 rules
+ */
+
+#ifndef APEX_HEADER_IDS_H
+#define APEX_HEADER_IDS_H
+
+#include "cmark-gfm.h"
+#include <stdbool.h>
+
+/**
+ * ID format options
+ */
+typedef enum {
+    APEX_ID_FORMAT_GFM = 0,      /* GFM style: "emoji-support" (with dashes, collapsed spaces) */
+    APEX_ID_FORMAT_MMD = 1,      /* MMD6 style: "emojisupport" (preserves dashes, removes spaces) */
+    APEX_ID_FORMAT_KRAMDOWN = 2 /* Kramdown style: "header-one" (spaces→dashes, removes em/en dashes) */
+} apex_id_format_t;
+
+/**
+ * Generate header ID from text
+ * @param text Header text
+ * @param format ID format (GFM or MMD)
+ * @return Newly allocated ID string (must be freed)
+ */
+char *apex_generate_header_id(const char *text, apex_id_format_t format);
+
+/**
+ * Extract text content from a heading node
+ * @param heading_node The heading AST node
+ * @return Newly allocated text string (must be freed)
+ */
+char *apex_extract_heading_text(cmark_node *heading_node);
+
+/**
+ * Extract manual header ID from heading text
+ * Supports:
+ * - MultiMarkdown: "Heading [id]" -> returns "id", removes "[id]" from text
+ * - Kramdown: "Heading {#id}" -> returns "id", removes "{#id}" from text
+ * - IAL: "Heading {: #id}" -> handled separately by IAL processor
+ *
+ * @param heading_text Heading text (will be modified to remove ID syntax)
+ * @param manual_id_out Output parameter for extracted ID (must be freed by caller)
+ * @return true if manual ID was found and extracted
+ */
+bool apex_extract_manual_header_id(char **heading_text, char **manual_id_out);
+
+/**
+ * Process manual header IDs in a heading node
+ * Extracts MMD [id] or Kramdown {#id} syntax and stores ID in user_data
+ * Updates the heading text node to remove the manual ID syntax
+ *
+ * @param heading_node The heading AST node
+ * @return true if manual ID was found and processed
+ */
+bool apex_process_manual_header_id(cmark_node *heading_node);
+
+#endif
+

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

@@ -0,0 +1,135 @@
+/**
+ * Simple Highlight Extension
+ * Converts ==text== to <mark>text</mark>
+ */
+
+#include "highlight.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+/**
+ * Process ==highlight== syntax as preprocessing
+ * Converts to <mark>text</mark> before parsing
+ */
+char *apex_process_highlights(const char *text) {
+    if (!text) return NULL;
+
+    size_t len = strlen(text);
+    size_t capacity = len * 2;  /* Room for <mark> 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 highlighting 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 ==highlight== (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 =: read[2] != '='
+         * - Character immediately before or after == is not +
+         * - Character after == is not whitespace
+         */
+        bool preceded_by_equals = (read > text && read[-1] == '=');
+        bool preceded_by_plus = (read > text && read[-1] == '+');
+        bool followed_by_plus = (read[2] == '+');
+        bool is_valid_highlight_start = (read[0] == '=' && read[1] == '=' &&
+                                         read[2] != '=' && read[2] != '}' &&
+                                         read[2] != '\0' && read[2] != '\n' &&
+                                         read[2] != '\r' && read[2] != ' ' && read[2] != '\t' &&
+                                         !preceded_by_equals && !preceded_by_plus && !followed_by_plus);
+
+        if (!in_code_block && !in_inline_code && !is_critic && is_valid_highlight_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_equals = (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] == '+');
+                    bool closing_followed_by_plus = (close[2] == '+');
+                    
+                    if (!closing_followed_by_equals && !closing_preceded_by_space && 
+                        !closing_preceded_by_plus && !closing_followed_by_plus) {
+                        break;
+                    }
+                }
+                close++;
+            }
+
+            if (*close && close[0] == '=' && close[1] == '=' && close[2] != '=') {
+                /* Found complete ==highlight== */
+                size_t content_len = close - (read + 2);
+
+                /* Ensure there's actual content (not just == on a line by itself) */
+                if (content_len > 0) {
+                    /* Write <mark> */
+                    const char *open_tag = "<mark>";
+                    size_t tag_len = strlen(open_tag);
+                    if (tag_len < remaining) {
+                        memcpy(write, open_tag, tag_len);
+                        write += tag_len;
+                        remaining -= tag_len;
+                    }
+
+                    /* Copy highlighted content */
+                    if (content_len < remaining) {
+                        memcpy(write, read + 2, content_len);
+                        write += content_len;
+                        remaining -= content_len;
+                    }
+
+                    /* Write </mark> */
+                    const char *close_tag = "</mark>";
+                    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++;
+        }
+    }
+
+    *write = '\0';
+    return output;
+}
+
+

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

@@ -0,0 +1,16 @@
+/**
+ * Simple Highlight Extension
+ * Handles ==text== syntax (not part of CommonMark, but widely supported)
+ */
+
+#ifndef APEX_HIGHLIGHT_H
+#define APEX_HIGHLIGHT_H
+
+/**
+ * Process ==highlight== syntax in text
+ * Converts ==text== to <mark>text</mark>
+ */
+char *apex_process_highlights(const char *text);
+
+#endif
+

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

@@ -0,0 +1,408 @@
+/**
+ * HTML Markdown Attributes Extension for Apex
+ * Implementation
+ */
+
+#include "html_markdown.h"
+#include "ial.h"
+#include "../html_renderer.h"
+#include "cmark-gfm.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdbool.h>
+
+/**
+ * Find the next HTML tag with markdown attribute
+ * Returns position of '<' or NULL if not found
+ */
+static const char *find_markdown_tag(const char *text, char *tag_name, size_t tag_name_size,
+                                     char *markdown_attr, size_t attr_size, size_t *tag_length) {
+    const char *pos = text;
+
+    while (*pos) {
+        /* Find opening < */
+        if (*pos == '<' && pos[1] != '/' && pos[1] != '!') {
+            const char *tag_start = pos;
+            pos++;
+
+            /* Extract tag name */
+            const char *name_start = pos;
+            while (*pos && (isalnum((unsigned char)*pos) || *pos == '-' || *pos == '_')) {
+                pos++;
+            }
+
+            size_t name_len = pos - name_start;
+            if (name_len == 0 || name_len >= tag_name_size) {
+                pos = tag_start + 1;
+                continue;
+            }
+
+            memcpy(tag_name, name_start, name_len);
+            tag_name[name_len] = '\0';
+
+            /* Look for markdown attribute in tag */
+            const char *tag_end = strchr(pos, '>');
+            if (!tag_end) {
+                pos = tag_start + 1;
+                continue;
+            }
+
+            /* Search for markdown= in attributes */
+            const char *attr_search = pos;
+            while (attr_search < tag_end) {
+                /* Skip whitespace */
+                while (attr_search < tag_end && isspace((unsigned char)*attr_search)) {
+                    attr_search++;
+                }
+
+                /* Check for markdown attribute */
+                if (strncmp(attr_search, "markdown=", 9) == 0) {
+                    attr_search += 9;
+
+                    /* Get attribute value */
+                    char quote = 0;
+                    if (*attr_search == '"' || *attr_search == '\'') {
+                        quote = *attr_search;
+                        attr_search++;
+                    }
+
+                    const char *value_start = attr_search;
+                    const char *value_end = value_start;
+
+                    if (quote) {
+                        value_end = strchr(value_start, quote);
+                        if (!value_end) value_end = tag_end;
+                    } else {
+                        while (*value_end && !isspace((unsigned char)*value_end) && *value_end != '>') {
+                            value_end++;
+                        }
+                    }
+
+                    size_t value_len = value_end - value_start;
+                    if (value_len < attr_size) {
+                        memcpy(markdown_attr, value_start, value_len);
+                        markdown_attr[value_len] = '\0';
+
+                        *tag_length = (tag_end - tag_start) + 1;
+                        return tag_start;
+                    }
+                }
+
+                /* Move to next attribute */
+                while (attr_search < tag_end && !isspace((unsigned char)*attr_search)) {
+                    attr_search++;
+                }
+            }
+
+            pos = tag_start + 1;
+        } else {
+            pos++;
+        }
+    }
+
+    return NULL;
+}
+
+/**
+ * Find matching closing tag
+ * Handles nested tags correctly
+ */
+static const char *find_closing_tag(const char *text, const char *tag_name) {
+    int depth = 1;
+    const char *pos = text;
+    size_t tag_len = strlen(tag_name);
+
+    while (*pos && depth > 0) {
+        if (*pos == '<') {
+            /* Check for closing tag */
+            if (pos[1] == '/' && strncasecmp(pos + 2, tag_name, tag_len) == 0 &&
+                (pos[2 + tag_len] == '>' || isspace((unsigned char)pos[2 + tag_len]))) {
+                depth--;
+                if (depth == 0) {
+                    /* Find the > */
+                    const char *end = strchr(pos, '>');
+                    return end ? end + 1 : NULL;
+                }
+            }
+            /* Check for opening tag (nested) */
+            else if (pos[1] != '/' && pos[1] != '!' &&
+                     strncasecmp(pos + 1, tag_name, tag_len) == 0 &&
+                     (pos[1 + tag_len] == '>' || isspace((unsigned char)pos[1 + tag_len]))) {
+                depth++;
+            }
+        }
+        pos++;
+    }
+
+    return NULL;
+}
+
+/**
+ * Process HTML tags with markdown attributes
+ * If img_attrs is non-NULL, image attributes (e.g. width/height from ref defs) are applied to images in markdown="1" regions.
+ */
+char *apex_process_html_markdown(const char *text, void *img_attrs) {
+    if (!text) return NULL;
+
+    image_attr_entry *attrs = (image_attr_entry *)img_attrs;
+
+    size_t text_len = strlen(text);
+    size_t output_capacity = text_len * 2;
+    char *output = malloc(output_capacity);
+    if (!output) return NULL;
+
+    const char *read_pos = text;
+    char *write_pos = output;
+    size_t remaining = output_capacity;
+
+    while (*read_pos) {
+        char tag_name[64];
+        char markdown_attr[64];
+        size_t tag_length;
+
+        /* Find next HTML tag with markdown attribute */
+        const char *tag_start = find_markdown_tag(read_pos, tag_name, sizeof(tag_name),
+                                                   markdown_attr, sizeof(markdown_attr), &tag_length);
+
+        if (!tag_start) {
+            /* No more markdown tags, copy rest */
+            size_t rest_len = strlen(read_pos);
+            if (rest_len < remaining) {
+                memcpy(write_pos, read_pos, rest_len);
+                write_pos += rest_len;
+                remaining -= rest_len;
+            }
+            break;
+        }
+
+        /* Copy text before tag */
+        size_t prefix_len = tag_start - read_pos;
+        if (prefix_len < remaining) {
+            memcpy(write_pos, read_pos, prefix_len);
+            write_pos += prefix_len;
+            remaining -= prefix_len;
+        }
+
+        /* Find content between tags */
+        const char *content_start = tag_start + tag_length;
+        const char *closing_tag = find_closing_tag(content_start, tag_name);
+
+        if (!closing_tag) {
+            /* No closing tag, just copy the opening tag */
+            if (tag_length < remaining) {
+                memcpy(write_pos, tag_start, tag_length);
+                write_pos += tag_length;
+                remaining -= tag_length;
+            }
+            read_pos = content_start;
+            continue;
+        }
+
+        /* Extract content */
+        size_t content_len = closing_tag - content_start;
+
+        /* Find the actual closing tag start for later */
+        const char *closing_tag_start = closing_tag;
+        while (closing_tag_start > content_start && *(closing_tag_start - 1) != '<') {
+            closing_tag_start--;
+        }
+        if (closing_tag_start > content_start && *(closing_tag_start - 1) == '<') {
+            closing_tag_start--;
+        }
+        content_len = closing_tag_start - content_start;
+
+        /* Process based on markdown attribute value */
+        bool parse_markdown = false;
+        bool parse_inline = false;
+
+        if (strcmp(markdown_attr, "1") == 0 || strcmp(markdown_attr, "block") == 0) {
+            parse_markdown = true;
+            parse_inline = false;
+        } else if (strcmp(markdown_attr, "span") == 0) {
+            parse_markdown = true;
+            parse_inline = true;
+        } else if (strcmp(markdown_attr, "0") == 0) {
+            parse_markdown = false;
+        }
+
+        if (parse_markdown && content_len > 0) {
+            /* Extract content */
+            char *content = malloc(content_len + 1);
+            if (content) {
+                memcpy(content, content_start, content_len);
+                content[content_len] = '\0';
+
+                /* Recursively process nested divs with markdown="1" BEFORE parsing */
+                /* This ensures nested divs are processed before cmark-gfm sees them */
+                char *processed_content = apex_process_html_markdown(content, img_attrs);
+                if (processed_content) {
+                    free(content);
+                    content = processed_content;
+                    content_len = strlen(content);
+                }
+
+                /* Create parser and parse */
+                /* Use CMARK_OPT_UNSAFE to allow raw HTML (including nested divs) */
+                int cmark_opts = CMARK_OPT_DEFAULT | CMARK_OPT_UNSAFE;
+                cmark_parser *parser = cmark_parser_new(cmark_opts);
+                if (parser) {
+                    cmark_parser_feed(parser, content, content_len);
+                    cmark_node *doc = cmark_parser_finish(parser);
+
+                    if (doc) {
+                        /* Process IAL in inner content so block/span IAL (e.g. {: .lead }) are applied */
+                        apex_process_ial_in_tree(doc, NULL);
+                        /* Apply image attributes (e.g. width/height from ref defs) so images in fenced divs get them */
+                        if (attrs) {
+                            apex_apply_image_attributes(doc, attrs);
+                        }
+                        /* Render to HTML with IAL attributes injected */
+                        char *html = apex_render_html_with_attributes(doc, cmark_opts);
+                        if (html) {
+                            /* Write opening tag (without markdown attribute) */
+                            char opening_tag[2048];
+                            size_t tag_written = 0;
+
+                            /* Reconstruct tag without markdown attribute */
+                            snprintf(opening_tag, sizeof(opening_tag), "<%s", tag_name);
+                            tag_written = strlen(opening_tag);
+
+                            /* Copy attributes except markdown */
+                            const char *attrs_start = strchr(tag_start + 1, ' ');
+                            if (attrs_start && attrs_start < content_start) {
+                                const char *attrs_end = strchr(attrs_start, '>');
+                                if (attrs_end) {
+                                    /* Parse and copy attributes, filtering out markdown attribute */
+                                    const char *attr_pos = attrs_start;
+                                    while (attr_pos < attrs_end) {
+                                        /* Skip whitespace */
+                                        while (attr_pos < attrs_end && isspace((unsigned char)*attr_pos)) {
+                                            attr_pos++;
+                                        }
+                                        if (attr_pos >= attrs_end) break;
+
+                                        /* Check if this is the markdown attribute */
+                                        if (strncmp(attr_pos, "markdown=", 9) == 0) {
+                                            /* Skip markdown attribute */
+                                            attr_pos += 9;
+                                            /* Skip attribute value */
+                                            if (*attr_pos == '"' || *attr_pos == '\'') {
+                                                char quote = *attr_pos++;
+                                                while (attr_pos < attrs_end && *attr_pos != quote) {
+                                                    if (*attr_pos == '\\' && attr_pos + 1 < attrs_end) attr_pos++;
+                                                    attr_pos++;
+                                                }
+                                                if (*attr_pos == quote) attr_pos++;
+                                            } else {
+                                                while (attr_pos < attrs_end && !isspace((unsigned char)*attr_pos) && *attr_pos != '>') {
+                                                    attr_pos++;
+                                                }
+                                            }
+                                            continue;
+                                        }
+
+                                        /* Copy this attribute */
+                                        const char *attr_start = attr_pos;
+                                        while (attr_pos < attrs_end && *attr_pos != '>') {
+                                            /* Check if we've reached the start of the next attribute */
+                                            if (attr_pos > attr_start && (isspace((unsigned char)*attr_pos) || *attr_pos == '>')) {
+                                                /* Check if next token is markdown= */
+                                                const char *next = attr_pos;
+                                                while (next < attrs_end && isspace((unsigned char)*next)) next++;
+                                                if (strncmp(next, "markdown=", 9) == 0) {
+                                                    break; /* Stop before markdown attribute */
+                                                }
+                                            }
+                                            attr_pos++;
+                                        }
+
+                                        /* Copy attribute to opening_tag */
+                                        size_t attr_len = attr_pos - attr_start;
+                                        if (tag_written + attr_len + 1 < sizeof(opening_tag)) {
+                                            opening_tag[tag_written++] = ' ';
+                                            memcpy(opening_tag + tag_written, attr_start, attr_len);
+                                            tag_written += attr_len;
+                                        }
+                                    }
+                                    opening_tag[tag_written++] = '>';
+                                    opening_tag[tag_written] = '\0';
+                                }
+                            } else {
+                                opening_tag[tag_written++] = '>';
+                                opening_tag[tag_written] = '\0';
+                            }
+
+                            if (tag_written < remaining) {
+                                memcpy(write_pos, opening_tag, tag_written);
+                                write_pos += tag_written;
+                                remaining -= tag_written;
+                            }
+
+                            /* Write parsed HTML (trim outer <p> tags if inline) */
+                            char *html_content = html;
+                            size_t html_len = strlen(html);
+
+                            if (parse_inline && html_len > 7 &&
+                                strncmp(html, "<p>", 3) == 0 &&
+                                strcmp(html + html_len - 5, "</p>\n") == 0) {
+                                /* Strip <p> tags for inline */
+                                html_content = html + 3;
+                                html_len -= 8;
+                                html_content[html_len] = '\0';
+                            }
+
+                            if (html_len < remaining) {
+                                memcpy(write_pos, html_content, html_len);
+                                write_pos += html_len;
+                                remaining -= html_len;
+                            }
+
+                            free(html);
+                        }
+                        cmark_node_free(doc);
+                    }
+                    cmark_parser_free(parser);
+                }
+                free(content);
+            }
+
+            /* Write closing tag */
+            size_t closing_len = closing_tag - closing_tag_start;
+            if (closing_len < remaining) {
+                memcpy(write_pos, closing_tag_start, closing_len);
+                write_pos += closing_len;
+                remaining -= closing_len;
+            }
+
+            /* Ensure newline after closing tag so following markdown is parsed correctly */
+            /* Check if closing tag ends with newline */
+            bool needs_newline = true;
+            if (closing_len > 0) {
+                const char *last_char = closing_tag_start + closing_len - 1;
+                if (*last_char == '\n' || (*last_char == '\r' && closing_len > 1 && *(last_char - 1) == '\n')) {
+                    needs_newline = false;
+                }
+            }
+            if (needs_newline && remaining > 0) {
+                *write_pos++ = '\n';
+                remaining--;
+            }
+        } else {
+            /* markdown="0" or no parsing - copy everything as-is */
+            size_t total_len = closing_tag - tag_start;
+            if (total_len < remaining) {
+                memcpy(write_pos, tag_start, total_len);
+                write_pos += total_len;
+                remaining -= total_len;
+            }
+        }
+
+        read_pos = closing_tag;
+    }
+
+    *write_pos = '\0';
+    return output;
+}
+

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

@@ -0,0 +1,42 @@
+/**
+ * HTML Markdown Attributes Extension for Apex
+ *
+ * Parse markdown inside HTML tags based on the `markdown` attribute:
+ *
+ * <div markdown="1">
+ * ## This markdown is parsed (block-level)
+ * </div>
+ *
+ * <span markdown="span">*emphasis* works</span>
+ *
+ * <div markdown="block">
+ * Same as markdown="1"
+ * </div>
+ *
+ * <div markdown="0">
+ * ## This is literal, not parsed
+ * </div>
+ */
+
+#ifndef APEX_HTML_MARKDOWN_H
+#define APEX_HTML_MARKDOWN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct image_attr_entry;
+
+/**
+ * Process HTML tags with markdown attributes (preprocessing)
+ * Returns newly allocated string with markdown content parsed.
+ * If img_attrs is non-NULL, image attributes (e.g. width/height from ref defs) are applied to images in markdown="1" regions.
+ */
+char *apex_process_html_markdown(const char *text, void *img_attrs);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APEX_HTML_MARKDOWN_H */
+