markly 0.15.3 → 0.17.0

data/ext/markly/front_matter.c

@@ -0,0 +1,141 @@
+#include "front_matter.h"
+#include "cmark-gfm.h"
+
+#include <string.h>
+
+// ---------------------------------------------------------------------------
+// Delimiter and info string parsing
+// ---------------------------------------------------------------------------
+
+// Return true if `input` is an opening front matter delimiter: "---" followed
+// by an optional info string and a newline.  No leading whitespace before
+// "---" is permitted.
+//
+// Note: some tools (e.g. Jekyll) also accept "..." as a closing delimiter,
+// derived from the YAML document-end marker.  We intentionally do not support
+// it here because this implementation is format-agnostic — the content between
+// the delimiters may be YAML, TOML, JSON, or anything else.  "..." has no
+// meaning outside of YAML, so "---" is the only unambiguous delimiter.
+static bool is_opening_delimiter(cmark_chunk *input) {
+  const unsigned char *p = input->data;
+  if (input->len < 3 || !(p[0] == '-' && p[1] == '-' && p[2] == '-'))
+    return false;
+  // A fourth consecutive dash produces a longer thematic break, not a
+  // front matter delimiter.
+  if (input->len > 3 && p[3] == '-')
+    return false;
+  return true;
+}
+
+// Return true if `input` is a closing front matter delimiter: exactly "---"
+// with optional trailing whitespace then a newline.  An info string is not
+// permitted on the closing delimiter.
+static bool is_closing_delimiter(cmark_chunk *input) {
+  const unsigned char *p = input->data;
+  int len = input->len;
+
+  if (len < 3 || !(p[0] == '-' && p[1] == '-' && p[2] == '-'))
+    return false;
+
+  for (int i = 3; i < len; i++) {
+    if (p[i] == '\n' || p[i] == '\r')
+      return true;
+    if (p[i] != ' ' && p[i] != '\t')
+      return false;
+  }
+  return true;
+}
+
+// Extract the optional info string from an opening delimiter line, e.g.
+// "--- yaml\n" yields "yaml".  Returns a zero-length chunk if absent.
+static cmark_chunk parse_info(cmark_chunk *input) {
+  const unsigned char *p = input->data + 3;
+  int len = input->len - 3;
+
+  while (len > 0 && (*p == ' ' || *p == '\t')) { p++; len--; }
+  while (len > 0 && (p[len-1] == '\n' || p[len-1] == '\r' ||
+                     p[len-1] == ' '  || p[len-1] == '\t'))
+    len--;
+
+  return (cmark_chunk){ .data = (unsigned char *)p,
+                        .len  = (bufsize_t)len,
+                        .alloc = 0 };
+}
+
+// ---------------------------------------------------------------------------
+// Node creation
+// ---------------------------------------------------------------------------
+
+static void create_front_matter_node(cmark_parser *parser) {
+  cmark_node *node =
+      cmark_node_new_with_mem(CMARK_NODE_FRONT_MATTER, parser->mem);
+
+  // Store identically to a code block: info string + literal content.
+  cmark_node_set_fence_info(node,
+      parser->front_matter_info.size > 0
+          ? (const char *)parser->front_matter_info.ptr
+          : "");
+
+  cmark_node_set_literal(node,
+      parser->front_matter_buf.size > 0
+          ? (const char *)parser->front_matter_buf.ptr
+          : "");
+
+  node->start_line = 1;
+  node->start_column = 1;
+  node->end_line = parser->line_number;
+  node->end_column = 3;
+
+  cmark_node *first = cmark_node_first_child(parser->root);
+  if (first)
+    cmark_node_insert_before(first, node);
+  else
+    cmark_node_append_child(parser->root, node);
+
+  parser->front_matter_scanning = false;
+  cmark_strbuf_clear(&parser->front_matter_buf);
+  cmark_strbuf_clear(&parser->front_matter_info);
+}
+
+// ---------------------------------------------------------------------------
+// State machine — called from S_process_line in blocks.c
+// ---------------------------------------------------------------------------
+
+bool cmark_front_matter_process_line(cmark_parser *parser, cmark_chunk *input) {
+  // NULL signals end-of-document: the whole document is the front matter.
+  if (input == NULL) {
+    create_front_matter_node(parser);
+    return true;
+  }
+
+  // Adjust for any offset already consumed (e.g. a UTF-8 BOM on line 1).
+  cmark_chunk adjusted = {
+    .data  = input->data + parser->offset,
+    .len   = input->len  - parser->offset,
+    .alloc = 0,
+  };
+  input = &adjusted;
+
+  if (parser->line_number == 1) {
+    if (is_opening_delimiter(input)) {
+      parser->front_matter_scanning = true;
+      // Capture optional info string (e.g. "yaml" from "--- yaml\n").
+      cmark_chunk info = parse_info(input);
+      if (info.len > 0)
+        cmark_strbuf_put(&parser->front_matter_info, info.data, info.len);
+    }
+    return parser->front_matter_scanning;
+  }
+
+  if (!parser->front_matter_scanning)
+    return false;
+
+  if (is_closing_delimiter(input)) {
+    create_front_matter_node(parser);
+    return true;
+  }
+
+  // Accumulate this content line.
+  cmark_strbuf_put(&parser->front_matter_buf, input->data, input->len);
+  return true;
+}

data/ext/markly/front_matter.h

@@ -0,0 +1,24 @@
+#ifndef CMARK_FRONT_MATTER_H
+#define CMARK_FRONT_MATTER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmark-gfm.h"
+#include "parser.h"
+#include "chunk.h"
+
+// Called from S_process_line in blocks.c for every line when
+// CMARK_OPT_FRONT_MATTER is set.  Drives the front matter state machine
+// stored directly on the parser (front_matter_scanning / front_matter_buf).
+//
+// Returns true if the line was consumed by the front matter scanner and
+// should not be passed to the normal block parser.
+bool cmark_front_matter_process_line(cmark_parser *parser, cmark_chunk *input);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/markly/html.c

@@ -18,6 +18,34 @@ static void escape_html(cmark_strbuf *dest, const unsigned char *source,
   houdini_escape_html0(dest, source, length, 0);
 }
 
+static bufsize_t first_code_info_tag(cmark_chunk *info) {
+  bufsize_t first_tag = 0;
+  while (first_tag < info->len && !cmark_isspace(info->data[first_tag])) {
+    first_tag += 1;
+  }
+  return first_tag;
+}
+
+static void render_code_info_attrs(cmark_strbuf *html, cmark_chunk *info,
+                                   int options, bool pre_lang) {
+  bufsize_t first_tag = first_code_info_tag(info);
+
+  if (pre_lang) {
+    cmark_strbuf_puts(html, " lang=\"");
+  } else {
+    cmark_strbuf_puts(html, " class=\"language-");
+  }
+
+  escape_html(html, info->data, first_tag);
+
+  if (first_tag < info->len && (options & CMARK_OPT_FULL_INFO_STRING)) {
+    cmark_strbuf_puts(html, "\" data-meta=\"");
+    escape_html(html, info->data + first_tag + 1, info->len - first_tag - 1);
+  }
+
+  cmark_strbuf_putc(html, '"');
+}
+
 static void filter_html_block(cmark_html_renderer *renderer, uint8_t *data, size_t len) {
   cmark_strbuf *html = renderer->html;
   cmark_llist *it;
@@ -125,7 +153,11 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
     case CMARK_NODE_TEXT:
     case CMARK_NODE_CODE:
     case CMARK_NODE_HTML_INLINE:
-      escape_html(html, node->as.literal.data, node->as.literal.len);
+      if (node->type == CMARK_NODE_CODE) {
+        escape_html(html, node->as.code.literal.data, node->as.code.literal.len);
+      } else {
+        escape_html(html, node->as.literal.data, node->as.literal.len);
+      }
       break;
 
     case CMARK_NODE_LINEBREAK:
@@ -220,32 +252,17 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
       cmark_html_render_sourcepos(node, html, options);
       cmark_strbuf_puts(html, "><code>");
     } else {
-      bufsize_t first_tag = 0;
-      while (first_tag < node->as.code.info.len &&
-             !cmark_isspace(node->as.code.info.data[first_tag])) {
-        first_tag += 1;
-      }
-
       if (options & CMARK_OPT_GITHUB_PRE_LANG) {
         cmark_strbuf_puts(html, "<pre");
         cmark_html_render_sourcepos(node, html, options);
-        cmark_strbuf_puts(html, " lang=\"");
-        escape_html(html, node->as.code.info.data, first_tag);
-        if (first_tag < node->as.code.info.len && (options & CMARK_OPT_FULL_INFO_STRING)) {
-          cmark_strbuf_puts(html, "\" data-meta=\"");
-          escape_html(html, node->as.code.info.data + first_tag + 1, node->as.code.info.len - first_tag - 1);
-        }
-        cmark_strbuf_puts(html, "\"><code>");
+        render_code_info_attrs(html, &node->as.code.info, options, true);
+        cmark_strbuf_puts(html, "><code>");
       } else {
         cmark_strbuf_puts(html, "<pre");
         cmark_html_render_sourcepos(node, html, options);
-        cmark_strbuf_puts(html, "><code class=\"language-");
-        escape_html(html, node->as.code.info.data, first_tag);
-        if (first_tag < node->as.code.info.len && (options & CMARK_OPT_FULL_INFO_STRING)) {
-          cmark_strbuf_puts(html, "\" data-meta=\"");
-          escape_html(html, node->as.code.info.data + first_tag + 1, node->as.code.info.len - first_tag - 1);
-        }
-        cmark_strbuf_puts(html, "\">");
+        cmark_strbuf_puts(html, "><code");
+        render_code_info_attrs(html, &node->as.code.info, options, false);
+        cmark_strbuf_putc(html, '>');
       }
     }
 
@@ -327,8 +344,12 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
     break;
 
   case CMARK_NODE_CODE:
-    cmark_strbuf_puts(html, "<code>");
-    escape_html(html, node->as.literal.data, node->as.literal.len);
+    cmark_strbuf_puts(html, "<code");
+    if (node->as.code.info.len > 0) {
+      render_code_info_attrs(html, &node->as.code.info, options, false);
+    }
+    cmark_strbuf_putc(html, '>');
+    escape_html(html, node->as.code.literal.data, node->as.code.literal.len);
     cmark_strbuf_puts(html, "</code>");
     break;
 
@@ -457,6 +478,9 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
     }
     break;
 
+  case CMARK_NODE_FRONT_MATTER:
+    break;
+
   default:
     assert(false);
     break;

data/ext/markly/inlines.c

@@ -24,7 +24,6 @@ static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99";
 
 // Macros for creating various kinds of simple.
 #define make_str(subj, sc, ec, s) make_literal(subj, CMARK_NODE_TEXT, sc, ec, s)
-#define make_code(subj, sc, ec, s) make_literal(subj, CMARK_NODE_CODE, sc, ec, s)
 #define make_raw_html(subj, sc, ec, s) make_literal(subj, CMARK_NODE_HTML_INLINE, sc, ec, s)
 #define make_linebreak(mem) make_simple(mem, CMARK_NODE_LINEBREAK)
 #define make_softbreak(mem) make_simple(mem, CMARK_NODE_SOFTBREAK)
@@ -104,6 +103,18 @@ static CMARK_INLINE cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) {
   return e;
 }
 
+static CMARK_INLINE cmark_node *make_code(subject *subj, int start_column,
+                                          int end_column, cmark_chunk literal) {
+  cmark_node *e = (cmark_node *)subj->mem->calloc(1, sizeof(*e));
+  cmark_strbuf_init(subj->mem, &e->content, 0);
+  e->type = CMARK_NODE_CODE;
+  e->as.code.literal = literal;
+  e->start_line = e->end_line = subj->line;
+  e->start_column = start_column + 1 + subj->column_offset + subj->block_offset;
+  e->end_column = end_column + 1 + subj->column_offset + subj->block_offset;
+  return e;
+}
+
 // Like make_str, but parses entities.
 static cmark_node *make_str_with_entities(subject *subj,
                                           int start_column, int end_column,
@@ -385,6 +396,39 @@ static void S_normalize_code(cmark_strbuf *s) {
 
 }
 
+static bufsize_t scan_inline_code_info_prefix(subject *subj, bufsize_t start) {
+  if (start >= subj->input.len ||
+      !cmark_is_inline_code_info_start_char((char)subj->input.data[start]) ||
+      (start > 0 && cmark_is_inline_code_info_char(
+                        (char)subj->input.data[start - 1]))) {
+    return 0;
+  }
+
+  bufsize_t pos = start + 1;
+  while (pos < subj->input.len && cmark_is_inline_code_info_char(
+                                      (char)subj->input.data[pos])) {
+    pos++;
+  }
+
+  if (pos + 1 < subj->input.len && subj->input.data[pos] == ':' &&
+      subj->input.data[pos + 1] == '`') {
+    return pos;
+  }
+
+  return 0;
+}
+
+static bufsize_t find_inline_code_info_prefix(subject *subj, bufsize_t start,
+                                              bufsize_t limit) {
+  while (start < limit) {
+    if (scan_inline_code_info_prefix(subj, start)) {
+      return start;
+    }
+    start++;
+  }
+
+  return 0;
+}
 
 // Parse backtick code section or raw backticks, return an inline.
 // Assumes that the subject has a backtick at the current position.
@@ -403,12 +447,35 @@ static cmark_node *handle_backticks(subject *subj, int options) {
                      endpos - startpos - openticks.len);
     S_normalize_code(&buf);
 
-    cmark_node *node = make_code(subj, startpos, endpos - openticks.len - 1, cmark_chunk_buf_detach(&buf));
-    adjust_subj_node_newlines(subj, node, endpos - startpos, openticks.len, options);
+    cmark_node *node = make_code(subj, startpos, endpos - openticks.len - 1,
+                                 cmark_chunk_buf_detach(&buf));
+    adjust_subj_node_newlines(subj, node, endpos - startpos, openticks.len,
+                              options);
     return node;
   }
 }
 
+static cmark_node *handle_inline_code_info(subject *subj, int options) {
+  bufsize_t startpos = subj->pos;
+  bufsize_t colonpos = scan_inline_code_info_prefix(subj, startpos);
+  if (colonpos == 0) {
+    return NULL;
+  }
+
+  cmark_chunk info =
+      cmark_chunk_dup(&subj->input, startpos, colonpos - startpos);
+  subj->pos = colonpos + 1;
+
+  cmark_node *node = handle_backticks(subj, options);
+  if (node->type != CMARK_NODE_CODE) {
+    cmark_node_free(node);
+    subj->pos = startpos;
+    return NULL;
+  }
+
+  node->as.code.info = chunk_clone(subj->mem, &info);
+  return node;
+}
 
 // Scan ***, **, or * and return number scanned, or 0.
 // Advances position.
@@ -1458,6 +1525,14 @@ static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent,
   if (c == 0) {
     return 0;
   }
+  if (options & CMARK_OPT_INLINE_CODE_INFO) {
+    new_inl = handle_inline_code_info(subj, options);
+  }
+  if (new_inl != NULL) {
+    append_child(parent, new_inl);
+    return 1;
+  }
+
   switch (c) {
   case '\r':
   case '\n':
@@ -1511,6 +1586,13 @@ static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent,
       break;
 
     endpos = subject_find_special_char(subj, options);
+    if (options & CMARK_OPT_INLINE_CODE_INFO) {
+      bufsize_t info_start =
+          find_inline_code_info_prefix(subj, subj->pos + 1, endpos);
+      if (info_start > 0 && info_start < endpos) {
+        endpos = info_start;
+      }
+    }
     contents = cmark_chunk_dup(&subj->input, subj->pos, endpos - subj->pos);
     startpos = subj->pos;
     subj->pos = endpos;

data/ext/markly/iterator.c

@@ -139,10 +139,15 @@ void cmark_node_own(cmark_node *root) {
       switch (cur->type) {
       case CMARK_NODE_TEXT:
       case CMARK_NODE_HTML_INLINE:
-      case CMARK_NODE_CODE:
       case CMARK_NODE_HTML_BLOCK:
         cmark_chunk_to_cstr(iter->mem, &cur->as.literal);
         break;
+      case CMARK_NODE_CODE:
+        cmark_chunk_to_cstr(iter->mem, &cur->as.code.literal);
+        if (cur->as.code.info.len > 0) {
+          cmark_chunk_to_cstr(iter->mem, &cur->as.code.info);
+        }
+        break;
       case CMARK_NODE_LINK:
         cmark_chunk_to_cstr(iter->mem, &cur->as.link.url);
         cmark_chunk_to_cstr(iter->mem, &cur->as.link.title);

data/ext/markly/latex.c

@@ -451,6 +451,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     // TODO
     break;
 
+  case CMARK_NODE_FRONT_MATTER:
+    break;
+
   default:
     assert(false);
     break;

data/ext/markly/man.c

@@ -257,6 +257,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     // TODO
     break;
 
+  case CMARK_NODE_FRONT_MATTER:
+    break;
+
   default:
     assert(false);
     break;