Add preserve-whitespace and inline-only options

rdar://76711302

Author: jmschonfeld

api_test/main.c

@@ -1152,6 +1152,49 @@ static void ref_source_pos(test_batch_runner *runner) {
   cmark_node_free(doc);
 }
 
+static void inline_only_opt(test_batch_runner *runner) {
+  static const char markdown[] =
+    "# My heading\n"
+    "> My block quote\n\n"
+    "- List item\n\n"
+    "[link](https://github.com)\n";
+  
+  cmark_node *doc = cmark_parse_document(markdown, sizeof(markdown) - 1, CMARK_OPT_INLINE_ONLY);
+  char *html = cmark_render_html(doc, CMARK_OPT_DEFAULT, 0);
+  STR_EQ(runner, html, "<p># My heading\n"
+         "&gt; My block quote\n"
+         "\n"
+         "- List item\n"
+         "\n"
+         "<a href=\"https://github.com\">link</a>\n"
+         "</p>\n", "html is as expected");
+  free(html);
+  cmark_node_free(doc);
+}
+
+static void check_markdown_plaintext(test_batch_runner *runner, char *markdown) {
+  cmark_node *doc = cmark_parse_document(markdown, strlen(markdown), CMARK_OPT_PRESERVE_WHITESPACE);
+  cmark_node *pg = cmark_node_first_child(doc);
+  INT_EQ(runner, cmark_node_get_type(pg), CMARK_NODE_PARAGRAPH, "markdown '%s' did not produce a paragraph node", markdown);
+  cmark_node *textNode = cmark_node_first_child(pg);
+  INT_EQ(runner, cmark_node_get_type(textNode), CMARK_NODE_TEXT, "markdown '%s' did not produce a text node inside the paragraph node", markdown);
+  const char *text = cmark_node_get_literal(textNode);
+  STR_EQ(runner, text, markdown, "markdown '%s' resulted in '%s'", markdown, text);
+}
+
+static void preserve_whitespace_opt(test_batch_runner *runner) {
+  check_markdown_plaintext(runner, "hello");
+  check_markdown_plaintext(runner, "hello ");
+  check_markdown_plaintext(runner, " hello");
+  check_markdown_plaintext(runner, "    hello");
+  check_markdown_plaintext(runner, "hello    ");
+  check_markdown_plaintext(runner, "hel\nlo");
+  check_markdown_plaintext(runner, "hel\n\nlo");
+  check_markdown_plaintext(runner, "hel\nworld\nlo");
+  check_markdown_plaintext(runner, " hel \n world \n lo ");
+  check_markdown_plaintext(runner, "  hello \n  \n world  ");
+}
+
 int main() {
   int retval;
   test_batch_runner *runner = test_batch_runner_new();
@@ -1182,6 +1225,8 @@ int main() {
   source_pos(runner);
   source_pos_inlines(runner);
   ref_source_pos(runner);
+  inline_only_opt(runner);
+  preserve_whitespace_opt(runner);
 
   test_print_summary(runner);
   retval = test_ok(runner) ? 0 : 1;

src/blocks.c

@@ -67,7 +67,7 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
                           size_t len, bool eof);
 
 static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
-                           bufsize_t bytes);
+                           bufsize_t bytes, bool ensureEndsInNewline);
 
 static cmark_node *make_block(cmark_mem *mem, cmark_node_type tag,
                               int start_line, int start_column) {
@@ -687,6 +687,7 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
                           size_t len, bool eof) {
   const unsigned char *end = buffer + len;
   static const uint8_t repl[] = {239, 191, 189};
+  bool preserveWhitespace = parser->options & CMARK_OPT_PRESERVE_WHITESPACE;
 
   if (parser->last_buffer_ended_with_cr && *buffer == '\n') {
     // skip NL if last buffer ended with CR ; see #117
@@ -714,10 +715,10 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
     if (process) {
       if (parser->linebuf.size > 0) {
         cmark_strbuf_put(&parser->linebuf, buffer, chunk_len);
-        S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size);
+        S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size, !preserveWhitespace || !eof || eol < end);
         cmark_strbuf_clear(&parser->linebuf);
       } else {
-        S_process_line(parser, buffer, chunk_len);
+        S_process_line(parser, buffer, chunk_len, !preserveWhitespace || !eof || eol < end);
       }
     } else {
       if (eol < end && *eol == '\0') {
@@ -1023,6 +1024,8 @@ static cmark_node *check_open_blocks(cmark_parser *parser, cmark_chunk *input,
   *all_matched = false;
   cmark_node *container = parser->root;
   cmark_node_type cont_type;
+    
+    
 
   while (S_last_child_is_open(container)) {
     container = container->last_child;
@@ -1337,7 +1340,7 @@ static void add_text_to_container(cmark_parser *parser, cmark_node *container,
   // then treat this as a "lazy continuation line" and add it to
   // the open paragraph.
   if (parser->current != last_matched_container &&
-      container == last_matched_container && !parser->blank &&
+      container == last_matched_container && (!parser->blank || (parser->options & CMARK_OPT_PRESERVE_WHITESPACE)) &&
       S_type(parser->current) == CMARK_NODE_PARAGRAPH) {
     add_line(parser->current, input, parser);
   } else { // not a lazy continuation
@@ -1395,15 +1398,21 @@ static void add_text_to_container(cmark_parser *parser, cmark_node *container,
           container->as.heading.setext == false) {
         chop_trailing_hashtags(input);
       }
-      S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+      if ((parser->options & CMARK_OPT_PRESERVE_WHITESPACE) == 0)
+        S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
                        false);
       add_line(container, input, parser);
     } else {
       // create paragraph container for line
-      container = add_child(parser, container, CMARK_NODE_PARAGRAPH,
-                            parser->first_nonspace + 1);
-      S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
-                       false);
+      if (parser->options & CMARK_OPT_PRESERVE_WHITESPACE) {
+        container = add_child(parser, container, CMARK_NODE_PARAGRAPH,
+                              parser->offset + 1);
+      } else {
+        container = add_child(parser, container, CMARK_NODE_PARAGRAPH,
+                              parser->first_nonspace + 1);
+        S_advance_offset(parser, input, parser->first_nonspace - parser->offset,
+                           false);
+      }
       add_line(container, input, parser);
     }
 
@@ -1413,7 +1422,7 @@ static void add_text_to_container(cmark_parser *parser, cmark_node *container,
 
 /* See http://spec.commonmark.org/0.24/#phase-1-block-structure */
 static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
-                           bufsize_t bytes) {
+                           bufsize_t bytes, bool ensureEndsInNewline) {
   cmark_node *last_matched_container;
   bool all_matched = true;
   cmark_node *container;
@@ -1430,7 +1439,7 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
   bytes = parser->curline.size;
 
   // ensure line ends with a newline:
-  if (bytes == 0 || !S_is_line_end_char(parser->curline.ptr[bytes - 1]))
+  if (ensureEndsInNewline && (bytes == 0 || !S_is_line_end_char(parser->curline.ptr[bytes - 1])))
     cmark_strbuf_putc(&parser->curline, '\n');
 
   parser->offset = 0;
@@ -1463,7 +1472,9 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
 
   current = parser->current;
 
-  open_new_blocks(parser, &container, &input, all_matched);
+  // Only open new blocks if we're not limited to inline
+  if ((parser->options & CMARK_OPT_INLINE_ONLY) == 0)
+    open_new_blocks(parser, &container, &input, all_matched);
 
   /* parser->current might have changed if feed_reentrant was called */
   if (current == parser->current)
@@ -1490,7 +1501,7 @@ cmark_node *cmark_parser_finish(cmark_parser *parser) {
     return NULL;
 
   if (parser->linebuf.size) {
-    S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size);
+    S_process_line(parser, parser->linebuf.ptr, parser->linebuf.size, (parser->options & CMARK_OPT_PRESERVE_WHITESPACE) == 0);
     cmark_strbuf_clear(&parser->linebuf);
   }
 

src/include/cmark-gfm.h

@@ -769,6 +769,17 @@ char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmar
  */
 #define CMARK_OPT_FULL_INFO_STRING (1 << 16)
 
+/** Parse only inline markdown directives. Block directives will not be
+ * parsed (their literal representations will remain in the output).
+ */
+#define CMARK_OPT_INLINE_ONLY (1 << 18)
+
+/** Parse the markdown input without removing preceding/trailing whitespace and
+ * without converting newline characters to breaks. Using this option also
+ * enables the CMARK_OPT_INLINE_ONLY option.
+ */
+#define CMARK_OPT_PRESERVE_WHITESPACE ((1 << 19) | CMARK_OPT_INLINE_ONLY)
+
 /**
  * ## Version information
  */

src/inlines.c

@@ -1424,7 +1424,12 @@ static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent,
   switch (c) {
   case '\r':
   case '\n':
-    new_inl = handle_newline(subj);
+    if (options & CMARK_OPT_PRESERVE_WHITESPACE) {
+      advance(subj);
+      new_inl = make_str(subj, subj->pos - 1, subj->pos - 1, cmark_chunk_dup(&subj->input, subj->pos - 1, 1));
+    } else {
+      new_inl = handle_newline(subj);
+    }
     break;
   case '`':
     new_inl = handle_backticks(subj, options);
@@ -1490,7 +1495,7 @@ static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent,
     subj->pos = endpos;
 
     // if we're at a newline, strip trailing spaces.
-    if (S_is_line_end_char(peek_char(subj))) {
+    if ((options & CMARK_OPT_PRESERVE_WHITESPACE) == 0 && S_is_line_end_char(peek_char(subj))) {
       cmark_chunk_rtrim(&contents);
     }
 
@@ -1511,7 +1516,8 @@ void cmark_parse_inlines(cmark_parser *parser,
   subject subj;
   cmark_chunk content = {parent->content.ptr, parent->content.size, 0};
   subject_from_buf(parser->mem, parent->start_line, parent->start_column - 1 + parent->internal_offset, &subj, &content, refmap);
-  cmark_chunk_rtrim(&subj.input);
+  if ((options & CMARK_OPT_PRESERVE_WHITESPACE) == 0)
+    cmark_chunk_rtrim(&subj.input);
 
   while (!is_eof(&subj) && parse_inline(parser, &subj, parent, options))
     ;