apex-ruby 1.0.6

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

@@ -0,0 +1,39 @@
+#ifndef APEX_PLUGINS_H
+#define APEX_PLUGINS_H
+
+#include "../include/apex/apex.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Plugin phases */
+typedef enum {
+    APEX_PLUGIN_PHASE_PRE_PARSE  = 1 << 0,
+    APEX_PLUGIN_PHASE_BLOCK      = 1 << 1,
+    APEX_PLUGIN_PHASE_INLINE     = 1 << 2,
+    APEX_PLUGIN_PHASE_POST_RENDER= 1 << 3
+} apex_plugin_phase_mask;
+
+typedef struct apex_plugin_manager apex_plugin_manager;
+
+/* Discover and load plugins from project and user config dirs.
+ * Returns NULL if no plugins are found or an error occurs. */
+apex_plugin_manager *apex_plugins_load(const apex_options *options);
+
+/* Free all plugin resources. */
+void apex_plugins_free(apex_plugin_manager *manager);
+
+/* Run all text-based plugins for the given phase over the provided text.
+ * Returns newly allocated string on modification, or NULL if no changes.
+ */
+char *apex_plugins_run_text_phase(apex_plugin_manager *manager,
+                                  apex_plugin_phase_mask phase,
+                                  const char *text,
+                                  const apex_options *options);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APEX_PLUGINS_H */

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

@@ -0,0 +1,187 @@
+#include "../include/apex/apex.h"
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <stdio.h>
+
+/**
+ * Very small helper to JSON-escape a string for inclusion as a value.
+ * We only need to support the characters that can reasonably appear
+ * in markdown input: backslash, quote, and control newlines.
+ */
+char *apex_json_escape(const char *text) {
+    if (!text) return NULL;
+    size_t len = strlen(text);
+    /* Worst case every char becomes \uXXXX or escape; be generous */
+    size_t cap = len * 6 + 1;
+    char *out = malloc(cap);
+    if (!out) return NULL;
+
+    char *w = out;
+    for (size_t i = 0; i < len; i++) {
+        unsigned char c = (unsigned char)text[i];
+        switch (c) {
+            case '\\': *w++ = '\\'; *w++ = '\\'; break;
+            case '"':  *w++ = '\\'; *w++ = '"';  break;
+            case '\n': *w++ = '\\'; *w++ = 'n';  break;
+            case '\r': *w++ = '\\'; *w++ = 'r';  break;
+            case '\t': *w++ = '\\'; *w++ = 't';  break;
+            default:
+                if (c < 0x20) {
+                    /* Control character – encode as \u00XX */
+                    int written = snprintf(w, cap - (size_t)(w - out), "\\u%04X", c);
+                    if (written <= 0 || (size_t)written >= cap - (size_t)(w - out)) {
+                        free(out);
+                        return NULL;
+                    }
+                    w += written;
+                } else {
+                    *w++ = (char)c;
+                }
+        }
+    }
+    *w = '\0';
+    return out;
+}
+
+/**
+ * Run a single external plugin command for a text-based phase.
+ * Protocol:
+ *  - Host sends JSON on stdin with fields: version, plugin_id, phase, text.
+ *  - Plugin writes transformed text to stdout (no JSON response parsing).
+ */
+char *apex_run_external_plugin_command(const char *cmd,
+                                       const char *phase,
+                                       const char *plugin_id,
+                                       const char *text,
+                                       int timeout_ms) {
+    (void)timeout_ms; /* Reserved for future timeout handling */
+    if (!cmd || !*cmd || !text || !phase || !plugin_id) return NULL;
+
+    /* Build JSON request */
+    char *escaped = apex_json_escape(text);
+    if (!escaped) return NULL;
+
+    const char *prefix = "{ \"version\": 1, \"plugin_id\": \"";
+    const char *mid1   = "\", \"phase\": \"";
+    const char *mid2   = "\", \"text\": \"";
+    const char *suffix = "\" }\n";
+    size_t json_len = strlen(prefix) + strlen(plugin_id) +
+                      strlen(mid1) + strlen(phase) +
+                      strlen(mid2) + strlen(escaped) + strlen(suffix);
+    char *json = malloc(json_len + 1);
+    if (!json) {
+        free(escaped);
+        return NULL;
+    }
+    snprintf(json, json_len + 1, "%s%s%s%s%s%s%s",
+             prefix, plugin_id, mid1, phase, mid2, escaped, suffix);
+    free(escaped);
+
+    int in_pipe[2];
+    int out_pipe[2];
+    if (pipe(in_pipe) == -1 || pipe(out_pipe) == -1) {
+        free(json);
+        return NULL;
+    }
+
+    pid_t pid = fork();
+    if (pid == -1) {
+        free(json);
+        close(in_pipe[0]); close(in_pipe[1]);
+        close(out_pipe[0]); close(out_pipe[1]);
+        return NULL;
+    }
+
+    if (pid == 0) {
+        /* Child: stdin from in_pipe[0], stdout to out_pipe[1] */
+        dup2(in_pipe[0], STDIN_FILENO);
+        dup2(out_pipe[1], STDOUT_FILENO);
+        close(in_pipe[0]); close(in_pipe[1]);
+        close(out_pipe[0]); close(out_pipe[1]);
+
+        execl("/bin/sh", "sh", "-c", cmd, (char *)NULL);
+        /* If exec fails */
+        _exit(127);
+    }
+
+    /* Parent */
+    close(in_pipe[0]);
+    close(out_pipe[1]);
+
+    /* Write JSON to child stdin */
+    ssize_t to_write = (ssize_t)json_len;
+    const char *p = json;
+    while (to_write > 0) {
+        ssize_t written = write(in_pipe[1], p, (size_t)to_write);
+        if (written <= 0) break;
+        p += written;
+        to_write -= written;
+    }
+    close(in_pipe[1]);
+    free(json);
+
+    /* Read all of child's stdout */
+    size_t cap = 8192;
+    size_t size = 0;
+    char *buf = malloc(cap);
+    if (!buf) {
+        close(out_pipe[0]);
+        /* Reap child */
+        int status;
+        waitpid(pid, &status, 0);
+        return NULL;
+    }
+
+    for (;;) {
+        if (size + 4096 > cap) {
+            cap *= 2;
+            char *nb = realloc(buf, cap);
+            if (!nb) {
+                free(buf);
+                close(out_pipe[0]);
+                int status;
+                waitpid(pid, &status, 0);
+                return NULL;
+            }
+            buf = nb;
+        }
+        ssize_t n = read(out_pipe[0], buf + size, 4096);
+        if (n < 0) {
+            if (errno == EINTR) continue;
+            free(buf);
+            close(out_pipe[0]);
+            int status;
+            waitpid(pid, &status, 0);
+            return NULL;
+        }
+        if (n == 0) break;
+        size += (size_t)n;
+    }
+    close(out_pipe[0]);
+
+    /* Reap child; ignore status for now but ensure no zombies */
+    int status;
+    waitpid(pid, &status, 0);
+
+    buf[size] = '\0';
+    return buf;
+}
+
+/**
+ * Backwards-compatible helper: use APEX_PRE_PARSE_PLUGIN env var as a single
+ * pre-parse plugin. This is effectively a thin wrapper around the generic
+ * external command runner.
+ */
+char *apex_run_preparse_plugin_env(const char *text, const apex_options *options) {
+    (void)options; /* reserved for future routing decisions */
+    const char *cmd = getenv("APEX_PRE_PARSE_PLUGIN");
+    if (!cmd || !*cmd || !text) {
+        return NULL;
+    }
+    return apex_run_external_plugin_command(cmd, "pre_parse", "env-pre-parse", text, 0);
+}
+

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

@@ -0,0 +1,263 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/* Simple structures for remote plugin directory entries */
+
+typedef struct apex_remote_plugin {
+    char *id;
+    char *title;
+    char *description;
+    char *author;
+    char *homepage;
+    char *repo;
+    struct apex_remote_plugin *next;
+} apex_remote_plugin;
+
+typedef struct apex_remote_plugin_list {
+    apex_remote_plugin *head;
+} apex_remote_plugin_list;
+
+void apex_remote_free_plugins(apex_remote_plugin_list *list) {
+    if (!list) return;
+    apex_remote_plugin *p = list->head;
+    while (p) {
+        apex_remote_plugin *next = p->next;
+        free(p->id);
+        free(p->title);
+        free(p->description);
+        free(p->author);
+        free(p->homepage);
+        free(p->repo);
+        free(p);
+        p = next;
+    }
+    free(list);
+}
+
+/* Fetch JSON from a URL using curl. Returns malloc'd buffer or NULL. */
+static char *apex_remote_fetch_json(const char *url) {
+    if (!url) return NULL;
+    /* Use curl -fsSL to fail on HTTP errors and be quiet except for data. */
+    char cmd[1024];
+    snprintf(cmd, sizeof(cmd), "curl -fsSL \"%s\"", url);
+
+    FILE *fp = popen(cmd, "r");
+    if (!fp) {
+        fprintf(stderr, "Error: failed to run curl. Is it installed?\n");
+        return NULL;
+    }
+
+    size_t cap = 4096;
+    size_t len = 0;
+    char *buf = malloc(cap);
+    if (!buf) {
+        pclose(fp);
+        return NULL;
+    }
+
+    size_t n;
+    while ((n = fread(buf + len, 1, cap - len, fp)) > 0) {
+        len += n;
+        if (len == cap) {
+            cap *= 2;
+            char *nb = realloc(buf, cap);
+            if (!nb) {
+                free(buf);
+                pclose(fp);
+                return NULL;
+            }
+            buf = nb;
+        }
+    }
+    buf[len] = '\0';
+    int rc = pclose(fp);
+    if (rc != 0) {
+        /* curl failed; treat as error */
+        free(buf);
+        fprintf(stderr, "Error: curl exited with status %d while fetching plugin directory.\n", rc);
+        return NULL;
+    }
+    return buf;
+}
+
+/* Very small JSON helper: extract string value for a key from an object snippet.
+ * Assumes JSON is well-formed and keys/values are double-quoted.
+ */
+static char *apex_remote_extract_string(const char *obj, const char *key) {
+    if (!obj || !key) return NULL;
+    char pattern[128];
+    snprintf(pattern, sizeof(pattern), "\"%s\"", key);
+    const char *p = strstr(obj, pattern);
+    if (!p) return NULL;
+    p = strchr(p + strlen(pattern), ':');
+    if (!p) return NULL;
+    p++;
+    while (*p == ' ' || *p == '\t') p++;
+    if (*p != '\"') return NULL;
+    p++;
+    const char *start = p;
+    while (*p && *p != '\"') {
+        if (*p == '\\' && p[1] != '\0') {
+            p += 2;
+        } else {
+            p++;
+        }
+    }
+    if (*p != '\"') return NULL;
+    size_t len = (size_t)(p - start);
+    char *out = malloc(len + 1);
+    if (!out) return NULL;
+    memcpy(out, start, len);
+    out[len] = '\0';
+    return out;
+}
+
+/* Parse a very small subset of JSON: { \"plugins\": [ { ... }, { ... } ] } */
+static apex_remote_plugin_list *apex_remote_parse_directory(const char *json) {
+    if (!json) return NULL;
+    const char *plugins_key = "\"plugins\"";
+    const char *p = strstr(json, plugins_key);
+    if (!p) {
+        fprintf(stderr, "Error: plugin directory JSON missing \"plugins\" key.\n");
+        return NULL;
+    }
+    p = strchr(p, '[');
+    if (!p) return NULL;
+    p++; /* move past '[' */
+
+    apex_remote_plugin_list *list = calloc(1, sizeof(apex_remote_plugin_list));
+    if (!list) return NULL;
+
+    while (*p) {
+        while (*p && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || *p == ',')) p++;
+        if (!*p || *p == ']') break;
+        if (*p != '{') {
+            break;
+        }
+        const char *obj_start = p;
+        int depth = 0;
+        while (*p) {
+            if (*p == '{') depth++;
+            else if (*p == '}') {
+                depth--;
+                if (depth == 0) {
+                    p++;
+                    break;
+                }
+            }
+            p++;
+        }
+        if (depth != 0) {
+            apex_remote_free_plugins(list);
+            return NULL;
+        }
+        size_t obj_len = (size_t)(p - obj_start);
+        char *obj = malloc(obj_len + 1);
+        if (!obj) {
+            apex_remote_free_plugins(list);
+            return NULL;
+        }
+        memcpy(obj, obj_start, obj_len);
+        obj[obj_len] = '\0';
+
+        apex_remote_plugin *rp = calloc(1, sizeof(apex_remote_plugin));
+        if (!rp) {
+            free(obj);
+            apex_remote_free_plugins(list);
+            return NULL;
+        }
+        rp->id = apex_remote_extract_string(obj, "id");
+        rp->title = apex_remote_extract_string(obj, "title");
+        rp->description = apex_remote_extract_string(obj, "description");
+        rp->author = apex_remote_extract_string(obj, "author");
+        rp->homepage = apex_remote_extract_string(obj, "homepage");
+        rp->repo = apex_remote_extract_string(obj, "repo");
+        free(obj);
+
+        if (!rp->id || !rp->repo) {
+            /* id and repo are required for use; drop this entry */
+            free(rp->id);
+            free(rp->title);
+            free(rp->description);
+            free(rp->author);
+            free(rp->homepage);
+            free(rp->repo);
+            free(rp);
+            continue;
+        }
+
+        rp->next = list->head;
+        list->head = rp;
+    }
+
+    return list;
+}
+
+/* Public helpers used by CLI */
+
+apex_remote_plugin_list *apex_remote_fetch_directory(const char *url) {
+    char *json = apex_remote_fetch_json(url);
+    if (!json) return NULL;
+    apex_remote_plugin_list *list = apex_remote_parse_directory(json);
+    free(json);
+    return list;
+}
+
+void apex_remote_print_plugins_filtered(apex_remote_plugin_list *list,
+                                        const char **installed_ids,
+                                        size_t installed_count) {
+    if (!list || !list->head) {
+        fprintf(stderr, "No plugins found in remote directory.\n");
+        return;
+    }
+    for (apex_remote_plugin *p = list->head; p; p = p->next) {
+        int skip = 0;
+        if (installed_ids && installed_count > 0 && p->id) {
+            for (size_t i = 0; i < installed_count; i++) {
+                if (installed_ids[i] && strcmp(installed_ids[i], p->id) == 0) {
+                    skip = 1;
+                    break;
+                }
+            }
+        }
+        if (skip) continue;
+
+        const char *title = p->title ? p->title : p->id;
+        const char *author = p->author ? p->author : "";
+        printf("%-20s - %s", p->id, title);
+        if (author && *author) {
+            printf("  (author: %s)", author);
+        }
+        printf("\n");
+        if (p->description && *p->description) {
+            printf("    %s\n", p->description);
+        }
+        if (p->homepage && *p->homepage) {
+            printf("    homepage: %s\n", p->homepage);
+        } else if (p->repo && *p->repo) {
+            printf("    repo: %s\n", p->repo);
+        }
+    }
+}
+
+void apex_remote_print_plugins(apex_remote_plugin_list *list) {
+    apex_remote_print_plugins_filtered(list, NULL, 0);
+}
+
+apex_remote_plugin *apex_remote_find_plugin(apex_remote_plugin_list *list, const char *id) {
+    if (!list || !id) return NULL;
+    for (apex_remote_plugin *p = list->head; p; p = p->next) {
+        if (p->id && strcmp(p->id, id) == 0) {
+            return p;
+        }
+    }
+    return NULL;
+}
+
+const char *apex_remote_plugin_repo(apex_remote_plugin *p) {
+    if (!p) return NULL;
+    return p->repo;
+}
+