apex-ruby 1.0.30 → 1.0.32

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

@@ -103,6 +103,168 @@ static void add_metadata_item(apex_metadata_item **list, const char *key, const
     *list = item;
 }
 
+/* Append code point cp as UTF-8 at out[*len], keeping room for the NUL. */
+static void yaml_append_utf8(char *out, size_t out_size, size_t *len, unsigned long cp) {
+    char buf[4];
+    size_t n;
+    if (cp < 0x80) {
+        buf[0] = (char)cp;
+        n = 1;
+    } else if (cp < 0x800) {
+        buf[0] = (char)(0xC0 | (cp >> 6));
+        buf[1] = (char)(0x80 | (cp & 0x3F));
+        n = 2;
+    } else if (cp < 0x10000) {
+        buf[0] = (char)(0xE0 | (cp >> 12));
+        buf[1] = (char)(0x80 | ((cp >> 6) & 0x3F));
+        buf[2] = (char)(0x80 | (cp & 0x3F));
+        n = 3;
+    } else if (cp <= 0x10FFFF) {
+        buf[0] = (char)(0xF0 | (cp >> 18));
+        buf[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
+        buf[2] = (char)(0x80 | ((cp >> 6) & 0x3F));
+        buf[3] = (char)(0x80 | (cp & 0x3F));
+        n = 4;
+    } else {
+        return;
+    }
+    if (*len + n >= out_size) return;
+    memcpy(out + *len, buf, n);
+    *len += n;
+}
+
+/* Parse exactly `digits` hex characters at p into *cp. */
+static bool yaml_parse_hex(const char *p, int digits, unsigned long *cp) {
+    unsigned long v = 0;
+    for (int i = 0; i < digits; i++) {
+        char c = p[i];
+        int d;
+        if (c >= '0' && c <= '9') d = c - '0';
+        else if (c >= 'a' && c <= 'f') d = c - 'a' + 10;
+        else if (c >= 'A' && c <= 'F') d = c - 'A' + 10;
+        else return false;
+        v = (v << 4) | (unsigned long)d;
+    }
+    *cp = v;
+    return true;
+}
+
+/* True if s is empty, whitespace, or a whitespace-led # comment. */
+static bool yaml_rest_is_ignorable(const char *s) {
+    while (*s == ' ' || *s == '\t') s++;
+    return *s == '\0' || *s == '#';
+}
+
+/**
+ * Unquote a single-line YAML scalar for the fallback parser, matching libyaml:
+ * single-quoted '' becomes ', double-quoted backslash escapes are decoded, and
+ * plain scalars are copied unchanged. A quoted scalar may be followed by a
+ * # comment. Output is truncated to fit out_size.
+ */
+static void yaml_unquote_scalar(const char *raw, char *out, size_t out_size) {
+    if (!out || out_size == 0) return;
+    out[0] = '\0';
+    if (!raw) return;
+
+    size_t len = 0;
+    char quote = raw[0];
+
+    if (quote == '\'') {
+        const char *p = raw + 1;
+        while (*p) {
+            if (*p == '\'') {
+                if (p[1] == '\'') {
+                    if (len + 1 < out_size) out[len++] = '\'';
+                    p += 2;
+                    continue;
+                }
+                if (yaml_rest_is_ignorable(p + 1)) {
+                    out[len] = '\0';
+                    return;
+                }
+                break;
+            }
+            if (len + 1 < out_size) out[len++] = *p;
+            p++;
+        }
+    } else if (quote == '"') {
+        const char *p = raw + 1;
+        while (*p) {
+            if (*p == '"') {
+                if (yaml_rest_is_ignorable(p + 1)) {
+                    out[len] = '\0';
+                    return;
+                }
+                break;
+            }
+            if (*p != '\\' || !p[1]) {
+                if (len + 1 < out_size) out[len++] = *p;
+                p++;
+                continue;
+            }
+
+            char esc = p[1];
+            unsigned long cp = 0;
+            int hex_digits = 0;
+            char simple = 0;
+            switch (esc) {
+                case '0': simple = '\0'; break;
+                case 'a': simple = '\a'; break;
+                case 'b': simple = '\b'; break;
+                case 't': case '\t': simple = '\t'; break;
+                case 'n': simple = '\n'; break;
+                case 'v': simple = '\v'; break;
+                case 'f': simple = '\f'; break;
+                case 'r': simple = '\r'; break;
+                case 'e': simple = '\x1B'; break;
+                case ' ': simple = ' '; break;
+                case '"': simple = '"'; break;
+                case '/': simple = '/'; break;
+                case '\\': simple = '\\'; break;
+                case 'N': cp = 0x85; break;
+                case '_': cp = 0xA0; break;
+                case 'L': cp = 0x2028; break;
+                case 'P': cp = 0x2029; break;
+                case 'x': hex_digits = 2; break;
+                case 'u': hex_digits = 4; break;
+                case 'U': hex_digits = 8; break;
+                default:
+                    /* Unknown escape: keep it literally */
+                    if (len + 2 < out_size) {
+                        out[len++] = '\\';
+                        out[len++] = esc;
+                    }
+                    p += 2;
+                    continue;
+            }
+
+            if (hex_digits) {
+                if (!yaml_parse_hex(p + 2, hex_digits, &cp)) {
+                    if (len + 2 < out_size) {
+                        out[len++] = '\\';
+                        out[len++] = esc;
+                    }
+                    p += 2;
+                    continue;
+                }
+                yaml_append_utf8(out, out_size, &len, cp);
+                p += 2 + hex_digits;
+            } else if (cp) {
+                yaml_append_utf8(out, out_size, &len, cp);
+                p += 2;
+            } else {
+                /* \0 would end the C string; drop it rather than truncate */
+                if (simple != '\0' && len + 1 < out_size) out[len++] = simple;
+                p += 2;
+            }
+        }
+    }
+
+    /* Plain scalar, or a quoted one that is unterminated or has trailing text */
+    strncpy(out, raw, out_size - 1);
+    out[out_size - 1] = '\0';
+}
+
 #ifdef APEX_HAVE_LIBYAML
 /* Recursively convert libyaml node to flat metadata items */
 static void yaml_node_to_flat_items(yaml_document_t *doc, yaml_node_t *node,
@@ -247,18 +409,26 @@ static void yaml_node_to_flat_items(yaml_document_t *doc, yaml_node_t *node,
     }
 }
 
-/* Parse YAML using libyaml - returns flat metadata items for backward compatibility */
-static apex_metadata_item *parse_yaml_with_libyaml(const char *text, size_t text_len, size_t *consumed) {
+/* Parse YAML using libyaml - returns flat metadata items for backward compatibility.
+ * On a libyaml parse error, a description is written to errbuf (if non-NULL).
+ * added_lines is the number of leading lines in text that are not in the
+ * source file, so reported line numbers match the file. */
+static apex_metadata_item *parse_yaml_with_libyaml(const char *text, size_t text_len, size_t *consumed,
+                                                   char *errbuf, size_t errbuf_size, size_t added_lines) {
     yaml_parser_t parser;
     yaml_document_t document;
     apex_metadata_item *items = NULL;
 
+    if (errbuf && errbuf_size) errbuf[0] = '\0';
+
     /* Skip opening --- if present */
     const char *yaml_start = text;
+    size_t line_offset = 0;
     if (text_len >= 3 && strncmp(text, "---", 3) == 0) {
         const char *newline = strchr(text + 3, '\n');
         if (newline) {
             yaml_start = newline + 1;
+            line_offset = 1;
         } else {
             yaml_start = text + 3;
         }
@@ -293,6 +463,12 @@ static apex_metadata_item *parse_yaml_with_libyaml(const char *text, size_t text
     yaml_parser_set_input_string(&parser, (const unsigned char *)yaml_start, yaml_content_len);
 
     if (!yaml_parser_load(&parser, &document)) {
+        if (errbuf && errbuf_size) {
+            snprintf(errbuf, errbuf_size, "%s (line %lu, column %lu)",
+                     parser.problem ? parser.problem : "parse error",
+                     (unsigned long)(parser.problem_mark.line + line_offset + 1 - added_lines),
+                     (unsigned long)(parser.problem_mark.column + 1));
+        }
         yaml_parser_delete(&parser);
         return NULL;
     }
@@ -324,18 +500,23 @@ static apex_metadata_item *parse_yaml_with_libyaml(const char *text, size_t text
  * Parse YAML front matter
  * Format: --- at start, key: value pairs, --- to close
  * If libyaml is available, attempts to use it for full YAML support (arrays, nested structures)
- * Falls back to simple line-by-line parser for backward compatibility
+ * Falls back to simple line-by-line parser for backward compatibility.
+ * If libyaml rejects the input, its error is written to errbuf (if non-NULL).
  */
-static apex_metadata_item *parse_yaml_metadata(const char *text, size_t *consumed) {
+static apex_metadata_item *parse_yaml_metadata_ex(const char *text, size_t *consumed,
+                                                  char *errbuf, size_t errbuf_size, size_t added_lines) {
     apex_metadata_item *items = NULL;
+    if (errbuf && errbuf_size) errbuf[0] = '\0';
 #ifdef APEX_HAVE_LIBYAML
     /* Try libyaml first for full YAML support */
     size_t text_len = strlen(text);
-    items = parse_yaml_with_libyaml(text, text_len, consumed);
+    items = parse_yaml_with_libyaml(text, text_len, consumed, errbuf, errbuf_size, added_lines);
     if (items) {
         return items;
     }
     /* Fall through to simple parser if libyaml parsing failed */
+#else
+    (void)added_lines;
 #endif
     const char *line_start = text;
     const char *line_end;
@@ -361,6 +542,11 @@ static apex_metadata_item *parse_yaml_metadata(const char *text, size_t *consume
             return items;
         }
 
+        if (*trimmed == '#') {
+            line_start = line_end + 1;
+            continue;
+        }
+
         /* Parse key: value */
         char *colon = strchr(line, ':');
         if (colon) {
@@ -368,19 +554,8 @@ static apex_metadata_item *parse_yaml_metadata(const char *text, size_t *consume
             char *key = trim_whitespace(line);
             char *value_ptr = trim_whitespace(colon + 1);
 
-            char final_value[1024] = {0};
-            strncpy(final_value, value_ptr, sizeof(final_value) - 1);
-
-            /* Strip quotes from value if present */
-            size_t value_len = strlen(final_value);
-            if (value_len >= 2 && ((final_value[0] == '"' && final_value[value_len - 1] == '"') ||
-                                   (final_value[0] == '\'' && final_value[value_len - 1] == '\''))) {
-                final_value[value_len - 1] = '\0';
-                memmove(final_value, final_value + 1, value_len - 1);
-                /* Re-trim after removing quotes */
-                trim_whitespace(final_value);
-                value_len = strlen(final_value);
-            }
+            char final_value[1024];
+            yaml_unquote_scalar(value_ptr, final_value, sizeof(final_value));
 
             if (*key) {
                 add_metadata_item(&items, key, final_value);
@@ -393,6 +568,10 @@ static apex_metadata_item *parse_yaml_metadata(const char *text, size_t *consume
     return items;
 }
 
+static apex_metadata_item *parse_yaml_metadata(const char *text, size_t *consumed) {
+    return parse_yaml_metadata_ex(text, consumed, NULL, 0, 0);
+}
+
 /**
  * Parse MultiMarkdown metadata
  * Format: key: value pairs at start of document, blank line to end
@@ -2232,9 +2411,15 @@ char *apex_metadata_replace_variables(const char *text, apex_metadata_item *meta
     return result;
 }
 
+static bool path_has_yaml_extension(const char *path) {
+    const char *dot = strrchr(path, '.');
+    if (!dot || strchr(dot, '/')) return false;
+    return strcasecmp(dot, ".yml") == 0 || strcasecmp(dot, ".yaml") == 0;
+}
+
 /**
  * Load metadata from a file
- * Auto-detects format based on first characters
+ * Auto-detects format based on first characters; .yml/.yaml files are always YAML
  */
 apex_metadata_item *apex_load_metadata_from_file(const char *filepath) {
     if (!filepath) return NULL;
@@ -2265,10 +2450,32 @@ apex_metadata_item *apex_load_metadata_from_file(const char *filepath) {
     apex_metadata_item *items = NULL;
     size_t consumed = 0;
 
+    /* .yml/.yaml files are YAML even without --- markers; add them so both
+     * libyaml and the fallback parser see a delimited block. */
+    size_t added_lines = 0;
+    if (strncmp(buffer, "---", 3) != 0 && path_has_yaml_extension(filepath)) {
+        bool needs_newline = bytes_read > 0 && buffer[bytes_read - 1] != '\n';
+        size_t wrapped_len = 4 + bytes_read + (needs_newline ? 1 : 0) + 4;
+        char *wrapped = malloc(wrapped_len + 1);
+        if (!wrapped) {
+            free(buffer);
+            return NULL;
+        }
+        snprintf(wrapped, wrapped_len + 1, "---\n%s%s---\n", buffer, needs_newline ? "\n" : "");
+        free(buffer);
+        buffer = wrapped;
+        added_lines = 1;
+    }
+
     /* Auto-detect format */
     if (strncmp(buffer, "---", 3) == 0) {
         /* YAML format */
-        items = parse_yaml_metadata(buffer, &consumed);
+        char yaml_error[256];
+        items = parse_yaml_metadata_ex(buffer, &consumed, yaml_error, sizeof(yaml_error), added_lines);
+        if (yaml_error[0]) {
+            fprintf(stderr, "Warning: YAML error in '%s': %s; using simple key: value parsing\n",
+                    filepath, yaml_error);
+        }
     } else if (buffer[0] == '%') {
         /* Pandoc format */
         items = parse_pandoc_metadata(buffer, &consumed);
@@ -2436,17 +2643,36 @@ apex_metadata_item *apex_parse_command_metadata(const char *arg) {
  * Merge multiple metadata lists with precedence
  * Later lists take precedence over earlier ones
  */
+/* Add or replace each item of src in *result (case-insensitive keys). */
+static void merge_metadata_into(apex_metadata_item **result, const apex_metadata_item *src) {
+    for (; src; src = src->next) {
+        apex_metadata_item *prev = NULL;
+        apex_metadata_item *curr = *result;
+        while (curr) {
+            if (strcasecmp(curr->key, src->key) == 0) {
+                if (prev) {
+                    prev->next = curr->next;
+                } else {
+                    *result = curr->next;
+                }
+                free(curr->key);
+                free(curr->value);
+                free(curr);
+                break;
+            }
+            prev = curr;
+            curr = curr->next;
+        }
+        add_metadata_item(result, src->key, src->value);
+    }
+}
+
 apex_metadata_item *apex_merge_metadata(apex_metadata_item *first, ...) {
     apex_metadata_item *result = NULL;
 
     /* Start with a copy of the first list (if any) */
-    apex_metadata_item *src;
-    if (first) {
-        src = first;
-        while (src) {
-            add_metadata_item(&result, src->key, src->value);
-            src = src->next;
-        }
+    for (apex_metadata_item *src = first; src; src = src->next) {
+        add_metadata_item(&result, src->key, src->value);
     }
 
     /* Merge remaining lists */
@@ -2455,40 +2681,22 @@ apex_metadata_item *apex_merge_metadata(apex_metadata_item *first, ...) {
 
     apex_metadata_item *next_list;
     while ((next_list = va_arg(args, apex_metadata_item*)) != NULL) {
-        /* For each item in next_list, add or replace in result */
-        src = next_list;
-        while (src) {
-            /* Remove existing item with same key (case-insensitive) */
-            apex_metadata_item *prev = NULL;
-            apex_metadata_item *curr = result;
-            while (curr) {
-                if (strcasecmp(curr->key, src->key) == 0) {
-                    /* Remove this item */
-                    if (prev) {
-                        prev->next = curr->next;
-                    } else {
-                        result = curr->next;
-                    }
-                    free(curr->key);
-                    free(curr->value);
-                    apex_metadata_item *to_free = curr;
-                    curr = curr->next;
-                    free(to_free);
-                    break;
-                }
-                prev = curr;
-                curr = curr->next;
-            }
-            /* Add new item */
-            add_metadata_item(&result, src->key, src->value);
-            src = src->next;
-        }
+        merge_metadata_into(&result, next_list);
     }
 
     va_end(args);
     return result;
 }
 
+apex_metadata_item *apex_merge_metadata_lists(apex_metadata_item *const *lists, size_t count) {
+    apex_metadata_item *result = NULL;
+    if (!lists) return NULL;
+    for (size_t i = 0; i < count; i++) {
+        if (lists[i]) merge_metadata_into(&result, lists[i]);
+    }
+    return result;
+}
+
 /**
  * Helper function to check if a string represents a true value
  */
@@ -2645,6 +2853,18 @@ void apex_apply_metadata_to_options(apex_metadata_item *metadata, apex_options *
             } else if (is_false_value(value)) {
                 options->enable_strikethrough = false;
             }
+        } else if (strcasecmp(key, "emoji") == 0 || strcasecmp(key, "enable-emoji") == 0 || strcasecmp(key, "enable_emoji") == 0) {
+            if (is_true_value(value)) {
+                options->enable_emoji = true;
+            } else if (is_false_value(value)) {
+                options->enable_emoji = false;
+            }
+        } else if (strcasecmp(key, "emoji-autocorrect") == 0 || strcasecmp(key, "emoji_autocorrect") == 0) {
+            if (is_true_value(value)) {
+                options->enable_emoji_autocorrect = true;
+            } else if (is_false_value(value)) {
+                options->enable_emoji_autocorrect = false;
+            }
         } else if (strcasecmp(key, "transforms") == 0 || strcasecmp(key, "metadata-transforms") == 0) {
             if (is_true_value(value)) {
                 options->enable_metadata_transforms = true;

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

@@ -107,9 +107,18 @@ void apex_metadata_fprint_yaml_document(FILE *fp, const apex_metadata_item *meta
  * Merge multiple metadata lists with precedence
  * Later lists take precedence over earlier ones
  * Returns a new merged list (caller must free with apex_free_metadata)
+ * The argument list is NULL-terminated, so an empty (NULL) list after the
+ * first ends the merge early; use apex_merge_metadata_lists when any list
+ * may be NULL.
  */
 apex_metadata_item *apex_merge_metadata(apex_metadata_item *first, ...);
 
+/**
+ * Merge count metadata lists in order (later lists win). NULL entries are
+ * skipped. Returns a new list (caller must free with apex_free_metadata).
+ */
+apex_metadata_item *apex_merge_metadata_lists(apex_metadata_item *const *lists, size_t count);
+
 /**
  * Apply metadata values to apex_options structure
  * Maps metadata keys to command-line options, allowing per-document control