apex-ruby 1.0.6

data/ext/apex_ext/apex_src/src/html_renderer.h

@@ -0,0 +1,126 @@
+/**
+ * Custom HTML Renderer for Apex
+ * Extends cmark-gfm's HTML renderer to support IAL attributes
+ */
+
+#ifndef APEX_HTML_RENDERER_H
+#define APEX_HTML_RENDERER_H
+
+#include "cmark-gfm.h"
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Render document to HTML with IAL attribute support
+ * This is a wrapper around cmark_render_html that injects attributes
+ */
+char *apex_render_html_with_attributes(cmark_node *document, int options);
+
+/**
+ * Inject header IDs into HTML output
+ * @param html The HTML output
+ * @param document The AST document
+ * @param generate_ids Whether to generate IDs
+ * @param use_anchors Whether to use <a> anchor tags instead of header IDs
+ * @param id_format 0=GFM (with dashes), 1=MMD (no dashes)
+ * @return Newly allocated HTML with IDs injected
+ */
+char *apex_inject_header_ids(const char *html, cmark_node *document, bool generate_ids, bool use_anchors, int id_format);
+
+/**
+ * Clean up HTML tag spacing
+ * - Compresses multiple spaces in tags to single spaces
+ * - Removes spaces before closing >
+ * @param html The HTML to clean
+ * @return Newly allocated cleaned HTML (must be freed)
+ */
+char *apex_clean_html_tag_spacing(const char *html);
+
+/**
+ * Collapse newlines and surrounding whitespace *between* adjacent tags in
+ * non-pretty HTML. For example:
+ *   </table>\n\n<figure>  ->  </table><figure>
+ *
+ * Only affects whitespace between a closing '>' and the next '<' where there
+ * is at least one newline, leaving text content and code blocks untouched.
+ * @param html The HTML to process
+ * @return Newly allocated HTML with inter-tag newlines collapsed (must be freed)
+ */
+char *apex_collapse_intertag_newlines(const char *html);
+
+/**
+ * Convert thead to tbody for relaxed tables
+ * Converts <thead><tr><th>...</th></tr></thead> to <tbody><tr><td>...</td></tr></tbody>
+ * for tables that were created from relaxed table input (no separator rows)
+ * @param html The HTML to process
+ * @return Newly allocated HTML with relaxed table thead converted to tbody (must be freed)
+ */
+char *apex_convert_relaxed_table_headers(const char *html);
+
+/**
+ * Remove blank lines within tables
+ * Removes lines containing only whitespace/newlines between <table> and </table> tags
+ * @param html The HTML to process
+ * @return Newly allocated HTML with blank lines removed from tables (must be freed)
+ */
+char *apex_remove_table_blank_lines(const char *html);
+
+/**
+ * Remove table rows that contain only em dashes (separator rows incorrectly rendered as data rows)
+ * This happens when smart typography converts --- to — in separator rows
+ * @param html The HTML to process
+ * @return Newly allocated HTML with separator rows removed (must be freed)
+ */
+char *apex_remove_table_separator_rows(const char *html);
+
+/**
+ * Adjust header levels in HTML based on Base Header Level metadata
+ * Shifts all headers by the specified offset (e.g., Base Header Level: 2 means h1->h2, h2->h3, etc.)
+ * @param html The HTML to process
+ * @param base_header_level The base header level (1-6, or 0 to disable)
+ * @return Newly allocated HTML with adjusted header levels (must be freed)
+ */
+char *apex_adjust_header_levels(const char *html, int base_header_level);
+
+/**
+ * Adjust quote styles in HTML based on Quotes Language metadata
+ * Replaces default English quote entities with language-specific quotes
+ * @param html The HTML to process
+ * @param quotes_language The quotes language (dutch/nl, english/en, french/fr, german/de, germanguillemets, spanish/es, swedish/sv, or NULL for default)
+ * @return Newly allocated HTML with adjusted quotes (must be freed)
+ */
+char *apex_adjust_quote_language(const char *html, const char *quotes_language);
+
+/**
+ * Apply ARIA labels and accessibility attributes to HTML output
+ * Adds aria-label to TOC nav elements, role attributes to figures and tables,
+ * and aria-describedby linking tables to their captions
+ * @param html The HTML to process
+ * @param document The AST document (currently unused but kept for API consistency)
+ * @return Newly allocated HTML with ARIA attributes injected (must be freed)
+ */
+char *apex_apply_aria_labels(const char *html, cmark_node *document);
+
+/**
+ * Convert <img> tags to <figure> with <figcaption> when alt/title/caption are present.
+ * If an image has caption="TEXT", that is always used and figure/figcaption is added
+ * regardless of enable_image_captions. Otherwise, when enable_image_captions is true:
+ * caption text prefers title when present, then alt (unless title_captions_only is true,
+ * in which case only images with a title get a caption). When title_captions_only is true,
+ * alt text is not used for captions.
+ * @param html The HTML to process
+ * @param enable_image_captions Whether to wrap images with title/alt in figure/figcaption
+ * @param title_captions_only When true, only add captions for images that have a title attribute
+ * @return Newly allocated HTML with image figures (must be freed), or NULL on error
+ */
+char *apex_convert_image_captions(const char *html, bool enable_image_captions, bool title_captions_only);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APEX_HTML_RENDERER_H */
+

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

@@ -0,0 +1,227 @@
+/**
+ * @file parser.c
+ * @brief Minimal Markdown parser implementation
+ *
+ * This is a placeholder implementation that will be replaced with
+ * cmark-gfm integration or custom parser.
+ */
+
+#include "apex/parser.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+typedef struct {
+    const apex_options *options;
+    const char *input;
+    size_t length;
+    size_t pos;
+    int line;
+    int column;
+} parser_state;
+
+void *apex_parser_new(const apex_options *options) {
+    parser_state *state = (parser_state *)calloc(1, sizeof(parser_state));
+    if (state) {
+        state->options = options;
+    }
+    return state;
+}
+
+void apex_parser_free(void *parser) {
+    if (parser) {
+        free(parser);
+    }
+}
+
+static apex_node *apex_node_new(apex_node_type type) {
+    apex_node *node = (apex_node *)calloc(1, sizeof(apex_node));
+    if (node) {
+        node->type = type;
+    }
+    return node;
+}
+
+static void apex_node_append_child(apex_node *parent, apex_node *child) {
+    if (!parent || !child) return;
+
+    child->parent = parent;
+    child->next = NULL;
+
+    if (parent->last_child) {
+        parent->last_child->next = child;
+        child->prev = parent->last_child;
+        parent->last_child = child;
+    } else {
+        parent->first_child = child;
+        parent->last_child = child;
+        child->prev = NULL;
+    }
+}
+
+void apex_node_free(apex_node *node) {
+    if (!node) return;
+
+    /* Free all children recursively */
+    apex_node *child = node->first_child;
+    while (child) {
+        apex_node *next = child->next;
+        apex_node_free(child);
+        child = next;
+    }
+
+    /* Free node data */
+    if (node->literal) {
+        free(node->literal);
+    }
+
+    /* Free type-specific data */
+    switch (node->type) {
+        case APEX_NODE_CODE_BLOCK:
+            if (node->data.code_block.info) {
+                free(node->data.code_block.info);
+            }
+            break;
+        case APEX_NODE_LINK:
+        case APEX_NODE_IMAGE:
+            if (node->data.link.url) {
+                free(node->data.link.url);
+            }
+            if (node->data.link.title) {
+                free(node->data.link.title);
+            }
+            break;
+        case APEX_NODE_CALLOUT:
+            if (node->data.callout.type) {
+                free(node->data.callout.type);
+            }
+            if (node->data.callout.title) {
+                free(node->data.callout.title);
+            }
+            break;
+        default:
+            break;
+    }
+
+    free(node);
+}
+
+/* Simple line-based parser for basic Markdown */
+static apex_node *parse_simple(parser_state *state) {
+    apex_node *doc = apex_node_new(APEX_NODE_DOCUMENT);
+    const char *input = state->input;
+    size_t len = state->length;
+    size_t pos = 0;
+
+    while (pos < len) {
+        /* Skip empty lines */
+        while (pos < len && (input[pos] == '\n' || input[pos] == '\r')) {
+            pos++;
+        }
+
+        if (pos >= len) break;
+
+        /* Check for heading */
+        if (input[pos] == '#') {
+            int level = 0;
+            size_t start = pos;
+
+            while (pos < len && input[pos] == '#' && level < 6) {
+                level++;
+                pos++;
+            }
+
+            /* Need space after # */
+            if (pos < len && input[pos] == ' ') {
+                pos++;
+                size_t text_start = pos;
+
+                /* Find end of line */
+                while (pos < len && input[pos] != '\n') {
+                    pos++;
+                }
+
+                apex_node *heading = apex_node_new(APEX_NODE_HEADING);
+                heading->data.heading.level = level;
+                heading->literal = strndup(input + text_start, pos - text_start);
+                apex_node_append_child(doc, heading);
+                continue;
+            }
+
+            /* Not a heading, reset */
+            pos = start;
+        }
+
+        /* Check for code fence */
+        if (pos + 3 <= len && input[pos] == '`' && input[pos+1] == '`' && input[pos+2] == '`') {
+            pos += 3;
+            size_t info_start = pos;
+
+            /* Read info string */
+            while (pos < len && input[pos] != '\n') {
+                pos++;
+            }
+
+            char *info = (info_start < pos) ? strndup(input + info_start, pos - info_start) : NULL;
+            if (pos < len) pos++; /* Skip newline */
+
+            size_t code_start = pos;
+
+            /* Find closing fence */
+            while (pos + 3 <= len) {
+                if (input[pos] == '`' && input[pos+1] == '`' && input[pos+2] == '`') {
+                    apex_node *code_block = apex_node_new(APEX_NODE_CODE_BLOCK);
+                    code_block->data.code_block.fenced = true;
+                    code_block->data.code_block.info = info;
+                    code_block->literal = strndup(input + code_start, pos - code_start);
+                    apex_node_append_child(doc, code_block);
+
+                    pos += 3;
+                    /* Skip to end of line */
+                    while (pos < len && input[pos] != '\n') pos++;
+                    break;
+                }
+                pos++;
+            }
+            continue;
+        }
+
+        /* Regular paragraph */
+        size_t para_start = pos;
+
+        /* Read until blank line or end */
+        while (pos < len) {
+            if (input[pos] == '\n') {
+                if (pos + 1 < len && input[pos + 1] == '\n') {
+                    /* Blank line ends paragraph */
+                    break;
+                }
+            }
+            pos++;
+        }
+
+        if (pos > para_start) {
+            apex_node *para = apex_node_new(APEX_NODE_PARAGRAPH);
+            para->literal = strndup(input + para_start, pos - para_start);
+            apex_node_append_child(doc, para);
+        }
+    }
+
+    return doc;
+}
+
+apex_node *apex_parse(void *parser, const char *markdown, size_t length) {
+    if (!parser || !markdown) {
+        return NULL;
+    }
+
+    parser_state *state = (parser_state *)parser;
+    state->input = markdown;
+    state->length = length;
+    state->pos = 0;
+    state->line = 1;
+    state->column = 1;
+
+    return parse_simple(state);
+}
+