apex-ruby 1.0.18 → 1.0.20

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

@@ -45,8 +45,10 @@ static int find_def_separator(const unsigned char *line, int len) {
         if (line[i] == ':' && line[i + 1] == ':') {
             /* Skip :: that's part of URL (://) */
             if (i + 3 <= len && line[i + 2] == '/') continue;
-            /* Skip :: that's part of div/custom element (::: or more) */
+            /* Skip ::: or more (div/custom element fence) */
             if (i > 0 && line[i - 1] == ':') continue;
+            /* Skip Leanpub {::marker /} syntax */
+            if (i > 0 && line[i - 1] == '{') continue;
             if (i + 2 < len && line[i + 2] == ':') continue;
             last_sep = i;
         }
@@ -140,6 +142,25 @@ static bool line_is_indented_code_block(const char *line, size_t len) {
     return (content < line + len) && !looks_like_list_marker(content);
 }
 
+/** True if :: at scan is part of Leanpub {::marker /} syntax, not a definition list. */
+static bool is_leanpub_marker_colons(const char *line_start, const char *colon_pos) {
+    return colon_pos > line_start && colon_pos[-1] == '{';
+}
+
+/** True if line is an ATX Markdown heading (# .. ######). */
+static bool is_atx_heading_line(const char *line, size_t len) {
+    size_t i = 0;
+    while (i < len && (line[i] == ' ' || line[i] == '\t')) i++;
+    if (i >= len || line[i] != '#') return false;
+    int hashes = 0;
+    while (i < len && line[i] == '#') {
+        hashes++;
+        i++;
+    }
+    if (hashes < 1 || hashes > 6) return false;
+    return i >= len || line[i] == ' ' || line[i] == '\t';
+}
+
 /**
  * Scans line for inline code backticks, updates state for next line, and returns
  * whether sep_pos is inside an inline code span. Single backticks toggle; 3+ are
@@ -172,6 +193,40 @@ static bool is_code_fence_line(const char *line, size_t len) {
     if (p + 3 <= line + len && p[0] == '`' && p[1] == '`' && p[2] == '`') {
         return true;
     }
+    if (p + 3 <= line + len && p[0] == '~' && p[1] == '~' && p[2] == '~') {
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Lines that clearly start a new Markdown block should not be buffered as
+ * potential definition-list terms (avoids eating blanks / mis-ordering fences).
+ */
+static bool is_block_start_line(const char *line, size_t len) {
+    const char *p = line;
+    const char *end = line + len;
+    while (p < end && (*p == ' ' || *p == '\t')) p++;
+    if (p >= end) return false;
+
+    if (*p == '>' || *p == '#' || *p == '|' || *p == '<') return true;
+
+    /* Unordered list markers */
+    if ((*p == '-' || *p == '*' || *p == '+') &&
+        (p + 1 >= end || p[1] == ' ' || p[1] == '\t')) {
+        return true;
+    }
+
+    /* Ordered list markers: 1. / 1) */
+    if (isdigit((unsigned char)*p)) {
+        const char *q = p;
+        while (q < end && isdigit((unsigned char)*q)) q++;
+        if (q < end && (*q == '.' || *q == ')') &&
+            (q + 1 >= end || q[1] == ' ' || q[1] == '\t')) {
+            return true;
+        }
+    }
+
     return false;
 }
 
@@ -247,6 +302,7 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
             if (scan[2] == ':') { scan++; continue; }
             const char *line_start = scan;
             while (line_start > text && line_start[-1] != '\n') line_start--;
+            if (is_leanpub_marker_colons(line_start, scan)) { scan++; continue; }
             const char *p = line_start;
             while (p < scan && (*p == ' ' || *p == '\t')) p++;
             if (p >= scan || *p != '[') { has_pattern = true; break; }
@@ -290,6 +346,7 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
     bool in_inline_code_span = false;
     char term_buffer[4096];
     int term_len = 0;
+    int blanks_after_term = 0;  /* blanks skipped while a potential term is buffered */
     bool dd_open = false;  /* True when we output <dd> but not yet </dd> (for Kramdown continuation) */
     bool prev_line_was_table_row = false;
 
@@ -316,13 +373,38 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
         /* Track code blocks */
         if (is_code_fence_line(line_start, line_length)) {
             in_code_block = !in_code_block;
-            if (in_def_list && in_code_block) {
-                /* Close def list before code block */
-                ENSURE_SPACE(10);
-                memcpy(write, "</dl>\n", 6);
-                write += 6;
-                remaining -= 6;
-                in_def_list = false;
+            if (in_code_block) {
+                /* Entering fenced code: close DL cleanly and flush buffered prose
+                 * before the fence. Extra blank after </dl> so CommonMark does not
+                 * treat the fence as part of an HTML block. */
+                if (dd_open) {
+                    ENSURE_SPACE(10);
+                    memcpy(write, "</dd>\n", 6);
+                    write += 6;
+                    remaining -= 6;
+                    dd_open = false;
+                }
+                if (in_def_list) {
+                    ENSURE_SPACE(10);
+                    memcpy(write, "</dl>\n\n", 7);
+                    write += 7;
+                    remaining -= 7;
+                    in_def_list = false;
+                }
+                if (term_len > 0) {
+                    ENSURE_SPACE((size_t)term_len + 2 + (size_t)blanks_after_term);
+                    memcpy(write, term_buffer, (size_t)term_len);
+                    write += term_len;
+                    remaining -= (size_t)term_len;
+                    *write++ = '\n';
+                    remaining--;
+                    for (int bi = 0; bi < blanks_after_term; bi++) {
+                        *write++ = '\n';
+                        remaining--;
+                    }
+                    term_len = 0;
+                    blanks_after_term = 0;
+                }
             }
             ENSURE_SPACE(line_length + 2);
             memcpy(write, line_start, line_length);
@@ -347,6 +429,20 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
 
         /* Skip definition processing inside indented code blocks */
         if (in_indented_code_block) {
+            if (term_len > 0) {
+                ENSURE_SPACE((size_t)term_len + 2 + (size_t)blanks_after_term);
+                memcpy(write, term_buffer, (size_t)term_len);
+                write += term_len;
+                remaining -= (size_t)term_len;
+                *write++ = '\n';
+                remaining--;
+                for (int bi = 0; bi < blanks_after_term; bi++) {
+                    *write++ = '\n';
+                    remaining--;
+                }
+                term_len = 0;
+                blanks_after_term = 0;
+            }
             ENSURE_SPACE(line_length + 2);
             memcpy(write, line_start, line_length);
             write += line_length;
@@ -424,6 +520,7 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
                 write += 6;
                 remaining -= 6;
                 term_len = 0;
+                blanks_after_term = 0;  /* blanks between term and : are normal DL spacing */
             } else if (in_def_list) {
                 /* Another : definition for same term */
                 if (dd_open) {
@@ -476,13 +573,18 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
                 in_def_list = false;
             }
             if (term_len > 0) {
-                ENSURE_SPACE((size_t)term_len + 2);
+                ENSURE_SPACE((size_t)term_len + 2 + (size_t)blanks_after_term);
                 memcpy(write, term_buffer, (size_t)term_len);
                 write += term_len;
                 remaining -= (size_t)term_len;
                 *write++ = '\n';
                 remaining--;
+                for (int bi = 0; bi < blanks_after_term; bi++) {
+                    *write++ = '\n';
+                    remaining--;
+                }
                 term_len = 0;
+                blanks_after_term = 0;
             }
             /* Extract term (before ::) and definition (after ::) */
             const char *term_start = line_start;
@@ -564,7 +666,8 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
             if (is_blank) {
                 /* Blank line: keep def list open (next line might be : definition for same term) */
                 if (term_len > 0) {
-                    /* Skip blank, keep term buffered */
+                    /* Remember blanks; restore them if this was not actually a term */
+                    blanks_after_term++;
                 } else if (!in_def_list) {
                     ENSURE_SPACE(2);
                     *write++ = '\n';
@@ -579,18 +682,25 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
                     in_def_list = false;
                 }
                 if (term_len > 0) {
-                    ENSURE_SPACE((size_t)term_len + 2);
+                    ENSURE_SPACE((size_t)term_len + 2 + (size_t)blanks_after_term);
                     memcpy(write, term_buffer, (size_t)term_len);
                     write += term_len;
                     remaining -= (size_t)term_len;
                     *write++ = '\n';
                     remaining--;
+                    for (int bi = 0; bi < blanks_after_term; bi++) {
+                        *write++ = '\n';
+                        remaining--;
+                    }
                     term_len = 0;
+                    blanks_after_term = 0;
                 }
                 const char *p = line_start;
                 while (p < line_end && (*p == ' ' || *p == '\t')) p++;
                 bool is_ref_def = (p < line_end && *p == '[' && memchr(p, ':', (size_t)(line_end - p)) != NULL);
-                if (is_ref_def || line_length >= sizeof(term_buffer) - 1) {
+                if (is_ref_def || is_atx_heading_line(line_start, line_length) ||
+                    is_block_start_line(line_start, line_length) ||
+                    line_length >= sizeof(term_buffer) - 1) {
                     ENSURE_SPACE(line_length + 2);
                     memcpy(write, line_start, line_length);
                     write += line_length;
@@ -601,6 +711,7 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
                     memcpy(term_buffer, line_start, line_length);
                     term_len = (int)line_length;
                     term_buffer[term_len] = '\0';
+                    blanks_after_term = 0;
                 }
             }
             }
@@ -625,14 +736,17 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
         write += 6;
     }
     if (in_def_list) {
-        memcpy(write, "</dl>\n", 6);
-        write += 6;
+        memcpy(write, "</dl>\n\n", 7);
+        write += 7;
     }
     if (term_len > 0) {
-        ENSURE_SPACE((size_t)term_len + 2);
+        ENSURE_SPACE((size_t)term_len + 2 + (size_t)blanks_after_term);
         memcpy(write, term_buffer, (size_t)term_len);
         write += term_len;
         *write++ = '\n';
+        for (int bi = 0; bi < blanks_after_term; bi++) {
+            *write++ = '\n';
+        }
     }
 
     *write = '\0';