apex-ruby 1.0.6

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

@@ -0,0 +1,163 @@
+/**
+ * Citations Extension for Apex
+ *
+ * Supports multiple citation syntaxes:
+ * - Pandoc: [@key], @key, [see @key, pp. 33-35]
+ * - MultiMarkdown: [#key], [p. 23][#key]
+ * - mmark: [@RFC2535], [@!RFC1034], [@RFC1034;@RFC1035]
+ */
+
+#ifndef APEX_CITATIONS_H
+#define APEX_CITATIONS_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
+#include "../../include/apex/apex.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Citation syntax types */
+typedef enum {
+    APEX_CITATION_PANDOC = 0,
+    APEX_CITATION_MMD = 1,
+    APEX_CITATION_MMARK = 2
+} apex_citation_syntax_t;
+
+/* Citation structure */
+typedef struct apex_citation {
+    char *key;                    /* Citation key (e.g., "doe99") */
+    char *prefix;                 /* Prefix text (e.g., "see") */
+    char *locator;                /* Locator (e.g., "pp. 33-35") */
+    char *suffix;                 /* Suffix text (e.g., "and passim") */
+    bool author_suppressed;       /* -@key syntax */
+    bool author_in_text;          /* @key syntax (no brackets) */
+    apex_citation_syntax_t syntax_type;  /* PANDOC, MMD, MMARK */
+    int position;                 /* Position in document */
+    struct apex_citation *next;   /* Linked list */
+} apex_citation;
+
+/* Bibliography entry structure (simplified CSL JSON) */
+typedef struct apex_bibliography_entry {
+    char *id;                     /* Citation key (e.g., "doe99") */
+    char *type;                   /* Entry type (article-journal, book, etc.) */
+    char *title;                  /* Title */
+    char *author;                 /* Author (formatted string) */
+    char *year;                   /* Year */
+    char *container_title;        /* Journal/container title */
+    char *publisher;              /* Publisher */
+    char *volume;                /* Volume */
+    char *page;                  /* Pages */
+    char *raw_data;              /* Raw JSON/BibTeX data for future use */
+    struct apex_bibliography_entry *next;  /* Linked list */
+} apex_bibliography_entry;
+
+/* Bibliography registry */
+typedef struct {
+    apex_bibliography_entry *entries;  /* Linked list of bibliography entries */
+    size_t count;                      /* Number of entries */
+} apex_bibliography_registry;
+
+/* Citation registry */
+typedef struct {
+    apex_citation *citations;     /* Linked list of citations */
+    size_t count;                 /* Number of citations */
+    apex_bibliography_registry *bibliography;  /* Bibliography entries */
+} apex_citation_registry;
+
+/**
+ * Create and return the citations extension
+ */
+cmark_syntax_extension *create_citations_extension(void);
+
+/**
+ * Process citations in text via preprocessing
+ * Extracts citations and stores them in registry
+ * Returns modified text with citations marked
+ */
+char *apex_process_citations(const char *text, apex_citation_registry *registry, const apex_options *options);
+
+/**
+ * Render citations in HTML output
+ * Replaces citation markers with formatted HTML
+ */
+char *apex_render_citations(const char *html, apex_citation_registry *registry, const apex_options *options);
+
+/**
+ * Generate bibliography HTML from cited entries
+ * Returns formatted bibliography HTML
+ */
+char *apex_generate_bibliography(apex_citation_registry *registry, const apex_options *options);
+
+/**
+ * Insert bibliography at <!-- REFERENCES --> marker or end of document
+ * Returns HTML with bibliography inserted
+ */
+char *apex_insert_bibliography(const char *html, apex_citation_registry *registry, const apex_options *options);
+
+/**
+ * Free citation registry
+ */
+void apex_free_citation_registry(apex_citation_registry *registry);
+
+/**
+ * Create a new citation
+ */
+apex_citation *apex_citation_new(const char *key, apex_citation_syntax_t syntax_type);
+
+/**
+ * Free a citation
+ */
+void apex_citation_free(apex_citation *citation);
+
+/**
+ * Load bibliography from file(s)
+ * Auto-detects format from extension (.bib, .json, .yaml, .yml)
+ * Returns bibliography registry, or NULL on error
+ */
+apex_bibliography_registry *apex_load_bibliography(const char **files, const char *base_directory);
+
+/**
+ * Load bibliography from a single file
+ * Auto-detects format from extension
+ */
+apex_bibliography_registry *apex_load_bibliography_file(const char *filepath);
+
+/**
+ * Parse BibTeX file
+ */
+apex_bibliography_registry *apex_parse_bibtex(const char *content);
+
+/**
+ * Parse CSL JSON file
+ */
+apex_bibliography_registry *apex_parse_csl_json(const char *content);
+
+/**
+ * Parse CSL YAML file
+ */
+apex_bibliography_registry *apex_parse_csl_yaml(const char *content);
+
+/**
+ * Find bibliography entry by ID
+ */
+apex_bibliography_entry *apex_find_bibliography_entry(apex_bibliography_registry *registry, const char *id);
+
+/**
+ * Free bibliography registry
+ */
+void apex_free_bibliography_registry(apex_bibliography_registry *registry);
+
+/**
+ * Free bibliography entry
+ */
+void apex_bibliography_entry_free(apex_bibliography_entry *entry);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APEX_CITATIONS_H */

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

@@ -0,0 +1,329 @@
+/**
+ * Critic Markup Extension for Apex
+ * Implementation
+ */
+
+#include "critic.h"
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <ctype.h>
+
+/**
+ * Scan for Critic Markup patterns
+ * Returns type and length if found
+ */
+typedef enum {
+    CRITIC_NONE = 0,
+    CRITIC_ADD,         /* {++text++} */
+    CRITIC_DEL,         /* {--text--} */
+    CRITIC_SUB,         /* {~~old~>new~~} */
+    CRITIC_HIGHLIGHT,   /* {==text==} */
+    CRITIC_COMMENT      /* {>>text<<} */
+} critic_type_t;
+
+static critic_type_t scan_critic_markup(const char *input, int len, int *consumed,
+                                        const char **content, int *content_len,
+                                        const char **old_text, int *old_len) {
+    if (len < 6) return CRITIC_NONE;  /* Minimum: {++x++} */
+
+    if (input[0] != '{') return CRITIC_NONE;
+
+    /* Check type */
+    critic_type_t type = CRITIC_NONE;
+    const char *close_marker = NULL;
+
+    if (input[1] == '+' && input[2] == '+') {
+        type = CRITIC_ADD;
+        close_marker = "++}";
+    } else if (input[1] == '-' && input[2] == '-') {
+        type = CRITIC_DEL;
+        close_marker = "--}";
+    } else if (input[1] == '~' && input[2] == '~') {
+        type = CRITIC_SUB;
+        close_marker = "~~}";
+    } else if (input[1] == '=' && input[2] == '=') {
+        type = CRITIC_HIGHLIGHT;
+        close_marker = "==}";
+    } else if (input[1] == '>' && input[2] == '>') {
+        type = CRITIC_COMMENT;
+        close_marker = "<<}";
+    } else {
+        return CRITIC_NONE;
+    }
+
+    *content = input + 3;  /* Skip opening marker */
+
+    /* Find closing marker */
+    const char *closer = strstr(*content, close_marker);
+    if (!closer) return CRITIC_NONE;
+
+    *content_len = closer - *content;
+    *consumed = (closer - input) + 3;  /* Include closing marker */
+
+    /* For substitutions, split on ~> */
+    if (type == CRITIC_SUB) {
+        const char *sep = strstr(*content, "~>");
+        if (sep && sep < closer) {
+            *old_len = sep - *content;
+            *old_text = *content;
+            *content = sep + 2;  /* Skip ~> */
+            *content_len = closer - *content;
+        }
+    }
+
+    return type;
+}
+
+/**
+ * Create HTML for critic markup based on mode
+ */
+static char *critic_to_html(critic_type_t type, const char *content, int content_len,
+                            const char *old_text, int old_len, critic_mode_t mode) {
+    char *html = NULL;
+    size_t html_len = content_len + old_len + 200;
+    html = malloc(html_len);
+    if (!html) return NULL;
+
+    switch (mode) {
+        case CRITIC_ACCEPT:
+            /* Show only additions and new text in substitutions */
+            switch (type) {
+                case CRITIC_ADD:
+                    snprintf(html, html_len, "%.*s", content_len, content);
+                    break;
+                case CRITIC_SUB:
+                    snprintf(html, html_len, "%.*s", content_len, content);
+                    break;
+                case CRITIC_HIGHLIGHT:
+                    /* Show highlight text without markup */
+                    snprintf(html, html_len, "%.*s", content_len, content);
+                    break;
+                case CRITIC_DEL:
+                case CRITIC_COMMENT:
+                    html[0] = '\0';  /* Remove deletions and comments */
+                    break;
+                default:
+                    html[0] = '\0';
+                    break;
+            }
+            break;
+
+        case CRITIC_REJECT:
+            /* Show only original text */
+            switch (type) {
+                case CRITIC_SUB:
+                    if (old_text && old_len > 0) {
+                        snprintf(html, html_len, "%.*s", old_len, old_text);
+                    } else {
+                        html[0] = '\0';
+                    }
+                    break;
+                case CRITIC_DEL:
+                    snprintf(html, html_len, "%.*s", content_len, content);
+                    break;
+                case CRITIC_HIGHLIGHT:
+                    /* Show highlight text without markup */
+                    snprintf(html, html_len, "%.*s", content_len, content);
+                    break;
+                case CRITIC_ADD:
+                case CRITIC_COMMENT:
+                    html[0] = '\0';  /* Remove additions and comments */
+                    break;
+                default:
+                    html[0] = '\0';
+                    break;
+            }
+            break;
+
+        case CRITIC_MARKUP:
+            /* Show markup with HTML classes */
+            switch (type) {
+                case CRITIC_ADD:
+                    snprintf(html, html_len, "<ins class=\"critic\">%.*s</ins>", content_len, content);
+                    break;
+                case CRITIC_DEL:
+                    snprintf(html, html_len, "<del class=\"critic\">%.*s</del>", content_len, content);
+                    break;
+                case CRITIC_SUB:
+                    if (old_text && old_len > 0) {
+                        snprintf(html, html_len,
+                                "<del class=\"critic break\">%.*s</del><ins class=\"critic break\">%.*s</ins>",
+                                old_len, old_text, content_len, content);
+                    } else {
+                        snprintf(html, html_len, "<ins class=\"critic\">%.*s</ins>", content_len, content);
+                    }
+                    break;
+                case CRITIC_HIGHLIGHT:
+                    snprintf(html, html_len, "<mark class=\"critic\">%.*s</mark>", content_len, content);
+                    break;
+                case CRITIC_COMMENT:
+                    snprintf(html, html_len, "<span class=\"critic comment\">%.*s</span>", content_len, content);
+                    break;
+                default:
+                    html[0] = '\0';
+                    break;
+            }
+            break;
+    }
+
+    return html;
+}
+
+/**
+ * Process Critic Markup in text nodes
+ */
+static void process_critic_in_text_node(cmark_node *node, critic_mode_t mode) {
+    const char *literal = cmark_node_get_literal(node);
+    if (!literal) return;
+
+    /* Look for critic markup - scan through entire string looking for { */
+    const char *search = literal;
+    const char *start = NULL;
+
+    while ((start = strchr(search, '{')) != NULL) {
+        /* Check if it's valid critic markup */
+        int consumed;
+        const char *content;
+        int content_len;
+        const char *old_text = NULL;
+        int old_len = 0;
+
+        critic_type_t type = scan_critic_markup(start, strlen(start), &consumed,
+                                               &content, &content_len, &old_text, &old_len);
+
+        if (type != CRITIC_NONE) {
+            /* Found valid critic markup */
+            size_t prefix_len = start - literal;
+            const char *suffix = start + consumed;
+
+            /* Generate HTML for the critic markup */
+            char *html = critic_to_html(type, content, content_len, old_text, old_len, mode);
+            if (!html) {
+                search = start + 1;
+                continue;
+            }
+
+            /* Create prefix text node if there's text before the markup */
+            if (prefix_len > 0) {
+                char *prefix = malloc(prefix_len + 1);
+                if (prefix) {
+                    memcpy(prefix, literal, prefix_len);
+                    prefix[prefix_len] = '\0';
+                    cmark_node_set_literal(node, prefix);
+                    free(prefix);
+                }
+            }
+
+            /* Create HTML inline node for the critic markup */
+            cmark_node *html_node = cmark_node_new(CMARK_NODE_HTML_INLINE);
+            cmark_node_set_literal(html_node, html);
+            free(html);
+
+            if (prefix_len > 0) {
+                /* Insert HTML after the prefix text node */
+                cmark_node_insert_after(node, html_node);
+            } else {
+                /* Replace the node entirely */
+                cmark_node_insert_before(node, html_node);
+                cmark_node_unlink(node);
+                cmark_node_free(node);
+                node = html_node;  /* Continue from the new node */
+            }
+
+            /* If there's suffix, create new text node and process it */
+            if (*suffix) {
+                cmark_node *suffix_node = cmark_node_new(CMARK_NODE_TEXT);
+                cmark_node_set_literal(suffix_node, suffix);
+                cmark_node_insert_after(html_node, suffix_node);
+
+                /* Recursively process the suffix */
+                process_critic_in_text_node(suffix_node, mode);
+            }
+
+            return;  /* Done processing this node */
+        }
+
+        /* Not critic markup, continue searching */
+        search = start + 1;
+    }
+}
+
+/**
+ * Recursively process Critic Markup in AST
+ */
+void apex_process_critic_markup_in_tree(cmark_node *node, critic_mode_t mode) {
+    if (!node) return;
+
+    /* Process current node if it's text */
+    if (cmark_node_get_type(node) == CMARK_NODE_TEXT) {
+        process_critic_in_text_node(node, mode);
+        return;  /* Don't recurse after modifying */
+    }
+
+    /* Recursively process children */
+    cmark_node *child = cmark_node_first_child(node);
+    while (child) {
+        cmark_node *next = cmark_node_next(child);  /* Save next before potential modification */
+        apex_process_critic_markup_in_tree(child, mode);
+        child = next;
+    }
+}
+
+/**
+ * Process Critic Markup in raw text (preprocessing approach)
+ * This is better than postprocessing because it avoids smart typography interference
+ */
+char *apex_process_critic_markup_text(const char *text, critic_mode_t mode) {
+    if (!text) return NULL;
+
+    size_t len = strlen(text);
+    size_t output_capacity = len * 2;  /* Generous estimate */
+    char *output = malloc(output_capacity);
+    if (!output) return NULL;
+
+    const char *read_pos = text;
+    char *write_pos = output;
+    size_t remaining_capacity = output_capacity;
+
+    while (*read_pos) {
+        /* Look for { */
+        if (*read_pos == '{') {
+            int consumed;
+            const char *content;
+            int content_len;
+            const char *old_text = NULL;
+            int old_len = 0;
+
+            critic_type_t type = scan_critic_markup(read_pos, strlen(read_pos), &consumed,
+                                                   &content, &content_len, &old_text, &old_len);
+
+            if (type != CRITIC_NONE) {
+                /* Found valid critic markup - convert to HTML */
+                char *html = critic_to_html(type, content, content_len, old_text, old_len, mode);
+                if (html) {
+                    size_t html_len = strlen(html);
+                    if (html_len < remaining_capacity) {
+                        memcpy(write_pos, html, html_len);
+                        write_pos += html_len;
+                        remaining_capacity -= html_len;
+                    }
+                    free(html);
+                }
+                read_pos += consumed;
+                continue;
+            }
+        }
+
+        /* Not critic markup, copy character */
+        if (remaining_capacity > 0) {
+            *write_pos++ = *read_pos;
+            remaining_capacity--;
+        }
+        read_pos++;
+    }
+
+    *write_pos = '\0';
+    return output;
+}
+

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

@@ -0,0 +1,48 @@
+/**
+ * Critic Markup Extension for Apex
+ *
+ * Supports CriticMarkup syntax for track changes:
+ * {++addition++}       - added text
+ * {--deletion--}       - deleted text
+ * {~~old~>new~~}       - substitution
+ * {==highlight==}      - highlighted text
+ * {>>comment<<}        - comment/annotation
+ */
+
+#ifndef APEX_CRITIC_H
+#define APEX_CRITIC_H
+
+#include <stdbool.h>
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Critic Markup rendering mode
+ */
+typedef enum {
+    CRITIC_ACCEPT,      /* Accept all changes */
+    CRITIC_REJECT,      /* Reject all changes */
+    CRITIC_MARKUP       /* Show markup with classes */
+} critic_mode_t;
+
+/**
+ * Process Critic Markup in an AST via postprocessing
+ */
+void apex_process_critic_markup_in_tree(cmark_node *document, critic_mode_t mode);
+
+/**
+ * Process Critic Markup in raw text (preprocessing approach)
+ * Returns newly allocated string with critic markup converted to HTML
+ */
+char *apex_process_critic_markup_text(const char *text, critic_mode_t mode);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APEX_CRITIC_H */
+