apex-ruby 1.0.29 → 1.0.31

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

@@ -12,12 +12,81 @@
 #include <stdbool.h>
 #include <ctype.h>
 
+/* Grow output buffer if needed; returns false on OOM. */
+static bool apex_relaxed_ensure(char **output, char **write, size_t *remaining,
+                                size_t *output_capacity, size_t *output_len,
+                                size_t needed) {
+    if (*remaining >= needed) {
+        return true;
+    }
+    size_t new_capacity = *output_capacity * 2;
+    while (new_capacity < *output_len + needed) {
+        new_capacity *= 2;
+    }
+    char *new_output = realloc(*output, new_capacity);
+    if (!new_output) {
+        return false;
+    }
+    *write = new_output + *output_len;
+    *output = new_output;
+    *remaining = new_capacity - *output_len;
+    *output_capacity = new_capacity;
+    return true;
+}
+
+/* Append a line (and optional newline) to the relaxed-tables output buffer. */
+static bool apex_relaxed_write_line(char **output, char **write, size_t *remaining,
+                                    size_t *output_capacity, size_t *output_len,
+                                    const char *line, size_t line_len, bool has_newline) {
+    size_t needed = line_len + (has_newline ? 1 : 0);
+    if (!apex_relaxed_ensure(output, write, remaining, output_capacity, output_len, needed)) {
+        return false;
+    }
+    memcpy(*write, line, line_len);
+    *write += line_len;
+    *remaining -= line_len;
+    *output_len += line_len;
+    if (has_newline) {
+        *(*write)++ = '\n';
+        (*remaining)--;
+        (*output_len)++;
+    }
+    return true;
+}
+
+/* Append a NUL-terminated string that already includes its trailing newline. */
+static bool apex_relaxed_write_cstr(char **output, char **write, size_t *remaining,
+                                    size_t *output_capacity, size_t *output_len,
+                                    const char *s) {
+    size_t len = strlen(s);
+    if (!apex_relaxed_ensure(output, write, remaining, output_capacity, output_len, len)) {
+        return false;
+    }
+    memcpy(*write, s, len);
+    *write += len;
+    *remaining -= len;
+    *output_len += len;
+    return true;
+}
+
 /**
  * Count the number of columns in a table row (by counting pipes)
  * Returns -1 if the line doesn't contain a pipe
  * Number of columns = number of pipe-separated cells
  * For GFM tables: | one | two | has 2 columns, one | two has 2 columns
  */
+/*
+ * If a [[wiki link]] opens at i and closes on the same line, return the index
+ * of its final ']'; otherwise return i. Pipes inside are target|label, not cells.
+ */
+static size_t skip_wiki_link(const char *line, size_t len, size_t i) {
+    if (i + 1 >= len || line[i] != '[' || line[i + 1] != '[') return i;
+    for (size_t j = i + 2; j + 1 < len; j++) {
+        if (line[j] == ']' && line[j + 1] == ']') return j + 1;
+    }
+    return i;
+}
+
 static int count_columns(const char *line, size_t len) {
     if (!line || len == 0) return -1;
 
@@ -34,6 +103,7 @@ static int count_columns(const char *line, size_t len) {
 
     /* Count pipes */
     for (size_t i = start; i < len; i++) {
+        i = skip_wiki_link(line, len, i);
         if (line[i] == '|') {
             has_pipe = true;
             pipe_count++;
@@ -267,6 +337,12 @@ static bool is_table_row(const char *line, size_t len) {
     bool has_content = false;
 
     for (size_t i = 0; i < len; i++) {
+        size_t link_end = skip_wiki_link(line, len, i);
+        if (link_end != i) {
+            has_content = true;
+            i = link_end;
+            continue;
+        }
         unsigned char c = (unsigned char)line[i];
         if (c == '|') {
             has_pipe = true;
@@ -322,6 +398,49 @@ static char *generate_dummy_header_row(int num_columns, bool starts_with_pipe) {
     return header;
 }
 
+#define APEX_RELAXED_TABLE_MARKER "<!--apex-relaxed-table-->\n"
+
+/*
+ * Write a relaxed table that had no separator: marker + first row + separator + rest.
+ * The marker tells HTML post-processing to demote thead->tbody (no real GFM header).
+ */
+typedef struct {
+    const char *start;
+    size_t len;
+    int columns;
+    bool starts_with_pipe;
+} apex_relaxed_table_row;
+
+static bool apex_relaxed_flush_injected_table(char **output, char **write, size_t *remaining,
+                                             size_t *output_capacity, size_t *output_len,
+                                             const apex_relaxed_table_row *rows, size_t rows_count,
+                                             bool row_newlines) {
+    if (rows_count < 2) return true;
+
+    char *sep = generate_separator_row(rows[0].columns, rows[0].starts_with_pipe);
+    if (!sep) return false;
+
+    bool ok = apex_relaxed_write_cstr(output, write, remaining, output_capacity, output_len,
+                                      APEX_RELAXED_TABLE_MARKER);
+    if (ok) {
+        ok = apex_relaxed_write_line(output, write, remaining, output_capacity, output_len,
+                                     rows[0].start, rows[0].len, true);
+    }
+    if (ok) {
+        ok = apex_relaxed_write_cstr(output, write, remaining, output_capacity, output_len, sep);
+    }
+    free(sep);
+    if (!ok) return false;
+
+    for (size_t i = 1; i < rows_count; i++) {
+        if (!apex_relaxed_write_line(output, write, remaining, output_capacity, output_len,
+                                     rows[i].start, rows[i].len, row_newlines)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 /**
  * Process relaxed tables - detect tables without separator rows and insert them
  */
@@ -364,6 +483,11 @@ static char *apex_process_relaxed_tables_impl(const char *text,
     size_t rows_capacity = 0;
     size_t rows_count = 0;
 
+    /* After a real separator row, subsequent pipe rows are table body —
+     * write them through. Do not re-accumulate and insert another separator
+     * (that used to split multi-row GFM tables and break following tables). */
+    bool after_real_separator = false;
+
     /* Track if we made any changes to avoid expensive strcmp */
     bool made_changes = false;
 
@@ -392,13 +516,15 @@ static char *apex_process_relaxed_tables_impl(const char *text,
         }
 
         /* Skip grid tables (lines starting with +) so relaxed table detection
-         * does not treat grid borders as pipe table rows. */
+         * does not treat grid borders as pipe table rows. Skip blockquote
+         * lines too: an injected separator row would lack the > prefix and
+         * split the table out of the blockquote. */
         if (!in_fenced_code) {
             const char *line_check = line_start;
             while (line_check < line_end && (*line_check == ' ' || *line_check == '\t')) {
                 line_check++;
             }
-            if (line_check < line_end && *line_check == '+') {
+            if (line_check < line_end && (*line_check == '+' || *line_check == '>')) {
                 if (rows_count > 0) {
                     for (size_t i = 0; i < rows_count; i++) {
                         if (rows[i].len < remaining) {
@@ -433,84 +559,17 @@ static char *apex_process_relaxed_tables_impl(const char *text,
 
         /* Check if this is a blank line */
         if (is_blank_line(line_start, line_len)) {
+            after_real_separator = false;
             /* Blank line: if we have accumulated table rows, process them */
             if (rows_count >= 2) {
-                /* We have a relaxed table - insert separator after first row */
-                /* First, write all rows except the last one */
-                for (size_t i = 0; i < rows_count; i++) {
-                    /* Write the row */
-                    if (rows[i].len < remaining) {
-                        memcpy(write, rows[i].start, rows[i].len);
-                        write += rows[i].len;
-                        remaining -= rows[i].len;
-                        output_len += rows[i].len;
-
-                        /* Write newline */
-                        if (has_newline && remaining > 0) {
-                            *write++ = '\n';
-                            remaining--;
-                            output_len++;
-                        }
-                    } else {
-                        /* Need to grow buffer */
-                        size_t new_capacity = output_capacity * 2;
-                        char *new_output = realloc(output, new_capacity);
-                        if (!new_output) {
-                            free(output);
-                            free(rows);
-                            return NULL;
-                        }
-                        write = new_output + output_len;
-                        output = new_output;
-                        remaining = new_capacity - output_len;
-                        output_capacity = new_capacity;
-
-                        memcpy(write, rows[i].start, rows[i].len);
-                        write += rows[i].len;
-                        remaining -= rows[i].len;
-                        output_len += rows[i].len;
-
-                        if (has_newline && remaining > 0) {
-                            *write++ = '\n';
-                            remaining--;
-                            output_len++;
-                        }
-                    }
-
-                    /* After first row, insert separator */
-                    if (i == 0) {
-                        made_changes = true;  /* We're inserting a separator, so output will differ */
-                        char *sep = generate_separator_row(rows[0].columns, rows[0].starts_with_pipe);
-                        if (sep) {
-                            size_t sep_len = strlen(sep);
-                            if (sep_len < remaining) {
-                                memcpy(write, sep, sep_len);
-                                write += sep_len;
-                                remaining -= sep_len;
-                                output_len += sep_len;
-                            } else {
-                                /* Need to grow buffer */
-                                size_t new_capacity = output_capacity * 2;
-                                char *new_output = realloc(output, new_capacity);
-                                if (!new_output) {
-                                    free(sep);
-                                    free(output);
-                                    free(rows);
-                                    return NULL;
-                                }
-                                write = new_output + output_len;
-                                output = new_output;
-                                remaining = new_capacity - output_len;
-                                output_capacity = new_capacity;
-
-                                memcpy(write, sep, sep_len);
-                                write += sep_len;
-                                remaining -= sep_len;
-                                output_len += sep_len;
-                            }
-                            free(sep);
-                        }
-                    }
+                /* Relaxed table: marker + first row + separator + remaining rows */
+                made_changes = true;
+                if (!apex_relaxed_flush_injected_table(&output, &write, &remaining, &output_capacity,
+                                                      &output_len, (const apex_relaxed_table_row *)rows,
+                                                      rows_count, true)) {
+                    free(output);
+                    free(rows);
+                    return NULL;
                 }
 
                 /* Reset rows */
@@ -614,42 +673,13 @@ static char *apex_process_relaxed_tables_impl(const char *text,
             }
 
             /* Write the separator row */
-            if (line_len < remaining) {
-                memcpy(write, line_start, line_len);
-                write += line_len;
-                remaining -= line_len;
-                output_len += line_len;
-
-                if (has_newline && remaining > 0) {
-                    *write++ = '\n';
-                    remaining--;
-                    output_len++;
-                }
-            } else {
-                /* Need to grow buffer */
-                size_t new_capacity = output_capacity * 2;
-                char *new_output = realloc(output, new_capacity);
-                if (!new_output) {
-                    free(output);
-                    free(rows);
-                    return NULL;
-                }
-                write = new_output + output_len;
-                output = new_output;
-                remaining = new_capacity - output_len;
-                output_capacity = new_capacity;
-
-                memcpy(write, line_start, line_len);
-                write += line_len;
-                remaining -= line_len;
-                output_len += line_len;
-
-                if (has_newline && remaining > 0) {
-                    *write++ = '\n';
-                    remaining--;
-                    output_len++;
-                }
+            if (!apex_relaxed_write_line(&output, &write, &remaining, &output_capacity, &output_len,
+                                        line_start, line_len, has_newline)) {
+                free(output);
+                free(rows);
+                return NULL;
             }
+            after_real_separator = true;
 
             read = line_end;
             if (has_newline) read++;
@@ -658,6 +688,7 @@ static char *apex_process_relaxed_tables_impl(const char *text,
 
         /* Check if this is a horizontal rule - skip it entirely */
         if (is_horizontal_rule(line_start, line_len)) {
+            after_real_separator = false;
             /* Write horizontal rule as-is and reset accumulated rows */
             if (rows_count > 0) {
                 /* Write accumulated rows first */
@@ -840,6 +871,19 @@ static char *apex_process_relaxed_tables_impl(const char *text,
         /* Process rows with or without leading pipes - both need separators if missing */
         int columns = in_fenced_code ? -1 : count_columns(line_start, line_len);
         if (columns > 0) {
+            /* Body rows after a real separator: pass through unchanged */
+            if (after_real_separator) {
+                if (!apex_relaxed_write_line(&output, &write, &remaining, &output_capacity, &output_len,
+                                            line_start, line_len, has_newline)) {
+                    free(output);
+                    free(rows);
+                    return NULL;
+                }
+                read = line_end;
+                if (has_newline) read++;
+                continue;
+            }
+
             /* Potential table row - add to accumulator */
             if (rows_count == 0) {
                 /* First row - allocate array */
@@ -919,80 +963,15 @@ static char *apex_process_relaxed_tables_impl(const char *text,
         }
 
         /* Not a table row - if we have accumulated rows, write them first */
+        after_real_separator = false;
         if (rows_count >= 2) {
-            /* We have a relaxed table - insert separator after first row */
-            for (size_t i = 0; i < rows_count; i++) {
-                if (rows[i].len < remaining) {
-                    memcpy(write, rows[i].start, rows[i].len);
-                    write += rows[i].len;
-                    remaining -= rows[i].len;
-                    output_len += rows[i].len;
-
-                    if (has_newline && remaining > 0) {
-                        *write++ = '\n';
-                        remaining--;
-                        output_len++;
-                    }
-                } else {
-                    /* Need to grow buffer */
-                    size_t new_capacity = output_capacity * 2;
-                    char *new_output = realloc(output, new_capacity);
-                    if (!new_output) {
-                        free(output);
-                        free(rows);
-                        return NULL;
-                    }
-                    write = new_output + output_len;
-                    output = new_output;
-                    remaining = new_capacity - output_len;
-                    output_capacity = new_capacity;
-
-                    memcpy(write, rows[i].start, rows[i].len);
-                    write += rows[i].len;
-                    remaining -= rows[i].len;
-                    output_len += rows[i].len;
-
-                    if (has_newline && remaining > 0) {
-                        *write++ = '\n';
-                        remaining--;
-                        output_len++;
-                    }
-                }
-
-                /* After first row, insert separator */
-                if (i == 0) {
-                    made_changes = true;  /* We're inserting a separator, so output will differ */
-                    char *sep = generate_separator_row(rows[0].columns, rows[0].starts_with_pipe);
-                    if (sep) {
-                        size_t sep_len = strlen(sep);
-                        if (sep_len < remaining) {
-                            memcpy(write, sep, sep_len);
-                            write += sep_len;
-                            remaining -= sep_len;
-                            output_len += sep_len;
-                        } else {
-                            /* Need to grow buffer */
-                            size_t new_capacity = output_capacity * 2;
-                            char *new_output = realloc(output, new_capacity);
-                            if (!new_output) {
-                                free(sep);
-                                free(output);
-                                free(rows);
-                                return NULL;
-                            }
-                            write = new_output + output_len;
-                            output = new_output;
-                            remaining = new_capacity - output_len;
-                            output_capacity = new_capacity;
-
-                            memcpy(write, sep, sep_len);
-                            write += sep_len;
-                            remaining -= sep_len;
-                            output_len += sep_len;
-                        }
-                        free(sep);
-                    }
-                }
+            made_changes = true;
+            if (!apex_relaxed_flush_injected_table(&output, &write, &remaining, &output_capacity,
+                                                  &output_len, (const apex_relaxed_table_row *)rows,
+                                                  rows_count, true)) {
+                free(output);
+                free(rows);
+                return NULL;
             }
             rows_count = 0;
         } else if (rows_count > 0) {
@@ -1080,74 +1059,13 @@ static char *apex_process_relaxed_tables_impl(const char *text,
 
     /* Handle any remaining accumulated rows at end of file */
     if (rows_count >= 2) {
-        /* We have a relaxed table - insert separator after first row */
-        for (size_t i = 0; i < rows_count; i++) {
-            if (rows[i].len < remaining) {
-                memcpy(write, rows[i].start, rows[i].len);
-                write += rows[i].len;
-                remaining -= rows[i].len;
-                output_len += rows[i].len;
-
-                *write++ = '\n';
-                remaining--;
-                output_len++;
-            } else {
-                /* Need to grow buffer */
-                size_t new_capacity = output_capacity * 2;
-                char *new_output = realloc(output, new_capacity);
-                if (!new_output) {
-                    free(output);
-                    free(rows);
-                    return NULL;
-                }
-                write = new_output + output_len;
-                output = new_output;
-                remaining = new_capacity - output_len;
-                output_capacity = new_capacity;
-
-                memcpy(write, rows[i].start, rows[i].len);
-                write += rows[i].len;
-                remaining -= rows[i].len;
-                output_len += rows[i].len;
-
-                *write++ = '\n';
-                remaining--;
-                output_len++;
-            }
-
-            /* After first row, insert separator */
-            if (i == 0) {
-                char *sep = generate_separator_row(rows[0].columns, rows[0].starts_with_pipe);
-                if (sep) {
-                    size_t sep_len = strlen(sep);
-                    if (sep_len < remaining) {
-                        memcpy(write, sep, sep_len);
-                        write += sep_len;
-                        remaining -= sep_len;
-                        output_len += sep_len;
-                    } else {
-                        /* Need to grow buffer */
-                        size_t new_capacity = output_capacity * 2;
-                        char *new_output = realloc(output, new_capacity);
-                        if (!new_output) {
-                            free(sep);
-                            free(output);
-                            free(rows);
-                            return NULL;
-                        }
-                        write = new_output + output_len;
-                        output = new_output;
-                        remaining = new_capacity - output_len;
-                        output_capacity = new_capacity;
-
-                        memcpy(write, sep, sep_len);
-                        write += sep_len;
-                        remaining -= sep_len;
-                        output_len += sep_len;
-                    }
-                    free(sep);
-                }
-            }
+        made_changes = true;
+        if (!apex_relaxed_flush_injected_table(&output, &write, &remaining, &output_capacity,
+                                              &output_len, (const apex_relaxed_table_row *)rows,
+                                              rows_count, true)) {
+            free(output);
+            free(rows);
+            return NULL;
         }
     } else if (rows_count == 1) {
         /* Only one row - not a table, write it as-is */