Add custom attributes using ^[foo][N] syntax

rdar://79015293

Author: iCharlesHu

api_test/main.c

@@ -1222,7 +1222,7 @@ static void check_markdown_attributes_node(test_batch_runner *runner, char *mark
   cmark_node_free(doc);
 }
 
-static void verify_custome_attributes_node(test_batch_runner *runner) {
+static void verify_custom_attributes_node(test_batch_runner *runner) {
   // Should produce a TEXT node since there's no `()` to signify attributes
   check_markdown_attributes_node(runner, "^[]", CMARK_NODE_TEXT, NULL);
   check_markdown_attributes_node(runner, "^[](", CMARK_NODE_TEXT, NULL);
@@ -1234,6 +1234,103 @@ static void verify_custome_attributes_node(test_batch_runner *runner) {
   check_markdown_attributes_node(runner, "^[](rainbow: 'extreme')", CMARK_NODE_ATTRIBUTE, "rainbow: 'extreme'");
 }
 
+static cmark_node* parse_custom_attributues_footnote(test_batch_runner *runner, const char *markdown, cmark_node **retdoc) {
+  cmark_node *doc = cmark_parse_document(markdown, strlen(markdown), CMARK_OPT_DEFAULT);
+  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);
+  *retdoc = doc;
+  return cmark_node_first_child(pg);
+}
+
+static void verify_custom_attributes_footnote_basic(test_batch_runner *runner) {
+  static const char markdown[] =
+    "^[caffe][1]\n"
+    "\n"
+    "^[1]: rainbow: 'extreme', colors: { r: 255, g: 0, b: 0 }, corgicopter: true";
+  cmark_node *doc;
+  cmark_node *attributeNode = parse_custom_attributues_footnote(runner, markdown, &doc);
+  INT_EQ(runner, cmark_node_get_type(attributeNode), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(attributeNode),
+         "rainbow: 'extreme', colors: { r: 255, g: 0, b: 0 }, corgicopter: true",
+         "markdown '%s' did not produce the right attribute in footnote", markdown);
+
+  cmark_node_free(doc);
+}
+
+static void verify_custom_attributes_footnote_multiple_footnotes(test_batch_runner *runner) {
+  static const char markdown[] =
+    "^[food][1] and ^[drinks][2]\n"
+    "\n"
+    "^[1]: rainbow: 'fun'\n"
+    "^[2]: magic: 42";
+  cmark_node *doc;
+  cmark_node *attributeNode1 = parse_custom_attributues_footnote(runner, markdown, &doc);
+  INT_EQ(runner, cmark_node_get_type(attributeNode1), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(attributeNode1), "rainbow: 'fun'", "markdown '%s' did not produce the right attribute in footnote", markdown);
+  cmark_node *textNode = cmark_node_next(attributeNode1); // "and"
+  cmark_node *attributeNode2 = cmark_node_next(textNode);
+  INT_EQ(runner, cmark_node_get_type(attributeNode2), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(attributeNode2), "magic: 42", "markdown '%s' did not produce the right attribute in footnote", markdown);
+
+  cmark_node_free(doc);
+}
+
+static void verify_custom_attributes_footnote_reuse(test_batch_runner *runner) {
+  static const char markdown[] =
+    "^[pizza][1], ^[sandwich][2], ^[ice cream][2], and ^[salad][1]\n"
+    "\n"
+    "^[1]: has_tomato: true\n"
+    "^[2]: price: 12";
+  cmark_node *doc;
+  cmark_node *pizzaNode = parse_custom_attributues_footnote(runner, markdown, &doc);
+  INT_EQ(runner, cmark_node_get_type(pizzaNode), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(pizzaNode), "has_tomato: true", "markdown '%s' did not produce the right attribute in footnote", markdown);
+  cmark_node *sandwichNode = cmark_node_next(cmark_node_next(pizzaNode));
+  INT_EQ(runner, cmark_node_get_type(sandwichNode), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(sandwichNode), "price: 12", "markdown '%s' did not produce the right attribute in footnote", markdown);
+  cmark_node *icecreamNode = cmark_node_next(cmark_node_next(sandwichNode));
+  INT_EQ(runner, cmark_node_get_type(icecreamNode), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(icecreamNode), "price: 12", "markdown '%s' did not produce the right attribute in footnote", markdown);
+  cmark_node *saladNode = cmark_node_next(cmark_node_next(icecreamNode));
+  INT_EQ(runner, cmark_node_get_type(saladNode), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(saladNode), "has_tomato: true", "markdown '%s' did not produce the right attribute in footnote", markdown);
+
+  cmark_node_free(doc);
+}
+
+static void verify_custom_attributes_footnote_mixed_content(test_batch_runner *runner) {
+  static const char markdown[] =
+    "^[attribute1][1], [a link][2], ^[attribute2][3], ^[attribute3][1]\n"
+    "\n"
+    "^[1]: rainbow: 'fun'\n"
+    "[2]: https://www.example.com\n"
+    "Lorem ipsum\n"
+    "\n"
+    "^[3]: universe: 42\n";
+  cmark_node *doc;
+  cmark_node *attributeNode1 = parse_custom_attributues_footnote(runner, markdown, &doc);
+  INT_EQ(runner, cmark_node_get_type(attributeNode1), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(attributeNode1), "rainbow: 'fun'", "markdown '%s' did not produce the right attribute in footnote", markdown);
+  cmark_node *linkNode = cmark_node_next(cmark_node_next(attributeNode1));
+  INT_EQ(runner, cmark_node_get_type(linkNode), CMARK_NODE_LINK, "markdown '%s' did not produce an link node", markdown);
+  STR_EQ(runner, cmark_node_get_url(linkNode), "https://www.example.com", "markdown '%s' did not produce the right link in footnote", markdown);
+  cmark_node *attributeNode2 = cmark_node_next(cmark_node_next(linkNode));
+  INT_EQ(runner, cmark_node_get_type(attributeNode2), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(attributeNode2), "universe: 42", "markdown '%s' did not produce the right attribute in footnote", markdown);
+  cmark_node *attributeNode3 = cmark_node_next(cmark_node_next(attributeNode2));
+  INT_EQ(runner, cmark_node_get_type(attributeNode3), CMARK_NODE_ATTRIBUTE, "markdown '%s' did not produce an attribute node", markdown);
+  STR_EQ(runner, cmark_node_get_attributes(attributeNode3), "rainbow: 'fun'", "markdown '%s' did not produce the right attribute in footnote", markdown);
+
+  cmark_node_free(doc);
+}
+
+static void verify_custom_attributes_node_with_footnote(test_batch_runner *runner) {
+  verify_custom_attributes_footnote_basic(runner);
+  verify_custom_attributes_footnote_multiple_footnotes(runner);
+  verify_custom_attributes_footnote_reuse(runner);
+  verify_custom_attributes_footnote_mixed_content(runner);
+}
+
 typedef void (*reentrant_call_func) (void);
 
 static cmark_node *reentrant_parse_inline_ext(cmark_syntax_extension *self, cmark_parser *parser,
@@ -1327,7 +1424,8 @@ int main() {
   ref_source_pos(runner);
   inline_only_opt(runner);
   preserve_whitespace_opt(runner);
-  verify_custome_attributes_node(runner);
+  verify_custom_attributes_node(runner);
+  verify_custom_attributes_node_with_footnote(runner);
   parser_interrupt(runner);
 
   test_print_summary(runner);

src/blocks.c

@@ -284,9 +284,10 @@ static bool resolve_reference_link_definitions(
   bufsize_t pos;
   cmark_strbuf *node_content = &b->content;
   cmark_chunk chunk = {node_content->ptr, node_content->size, 0};
-  while (chunk.len && chunk.data[0] == '[' &&
-         (pos = cmark_parse_reference_inline(parser->mem, &chunk,
-					     parser->refmap))) {
+  while ((chunk.len && chunk.data[0] == '[' &&
+            (pos = cmark_parse_reference_inline(parser->mem, &chunk, parser->refmap))) ||
+         (chunk.len && chunk.data[0] == '^' && chunk.data[1] == '[' &&
+            (pos = cmark_parse_reference_attributes_inline(parser->mem, &chunk, parser->refmap)))) {
 
     chunk.data += pos;
     chunk.len -= pos;

src/include/inlines.h

@@ -11,6 +11,7 @@ extern "C" {
 
 cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url);
 cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
+cmark_chunk cmark_clean_attributes(cmark_mem *mem, cmark_chunk *attributes);
 
 CMARK_GFM_EXPORT
 void cmark_parse_inlines(cmark_parser *parser,
@@ -21,6 +22,9 @@ void cmark_parse_inlines(cmark_parser *parser,
 bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
                                        cmark_map *refmap);
 
+bufsize_t cmark_parse_reference_attributes_inline(cmark_mem *mem, cmark_chunk *input,
+                                                  cmark_map *refmap);
+
 void cmark_inlines_add_special_character(cmark_parser *parser, unsigned char c, bool emphasis);
 void cmark_inlines_remove_special_character(cmark_parser *parser, unsigned char c, bool emphasis);
 

src/include/references.h

@@ -9,14 +9,18 @@ extern "C" {
 
 struct cmark_reference {
   cmark_map_entry entry;
+  bool is_attributes_reference;
   cmark_chunk url;
   cmark_chunk title;
+  cmark_chunk attributes;
 };
 
 typedef struct cmark_reference cmark_reference;
 
 void cmark_reference_create(cmark_map *map, cmark_chunk *label,
                             cmark_chunk *url, cmark_chunk *title);
+void cmark_reference_create_attributes(cmark_map *map, cmark_chunk *label,
+                                       cmark_chunk *attributes);
 cmark_map *cmark_reference_map_new(cmark_mem *mem);
 
 #ifdef __cplusplus

src/inlines.c

@@ -878,6 +878,12 @@ cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title) {
   return cmark_chunk_buf_detach(&buf);
 }
 
+// Clean custom attributes. This function uses `cmark_clean_url` internaly
+// because the requirements are the same
+cmark_chunk cmark_clean_attributes(cmark_mem *mem, cmark_chunk *attributes) {
+  return cmark_clean_url(mem, attributes);
+}
+
 // Parse an autolink or HTML tag.
 // Assumes the subject has a '<' character at the current position.
 static cmark_node *handle_pointy_brace(subject *subj, int options) {
@@ -933,10 +939,19 @@ static cmark_node *handle_pointy_brace(subject *subj, int options) {
 // Note:  unescaped brackets are not allowed in labels.
 // The label begins with `[` and ends with the first `]` character
 // encountered.  Backticks in labels do not start code spans.
-static int link_label(subject *subj, cmark_chunk *raw_label) {
+static int link_label(subject *subj, cmark_chunk *raw_label, bool parse_attribute_label) {
   bufsize_t startpos = subj->pos;
   int length = 0;
   unsigned char c;
+  
+  // If we are parsing attribute label, advance past ^
+  if (parse_attribute_label) {
+    if (peek_char(subj) == '^') {
+      advance(subj);
+    } else {
+      return 0;
+    }
+  }
 
   // advance past [
   if (peek_char(subj) == '[') {
@@ -963,8 +978,9 @@ static int link_label(subject *subj, cmark_chunk *raw_label) {
   }
 
   if (c == ']') { // match found
+    bufsize_t position = parse_attribute_label ? startpos + 2 : startpos + 1;
     *raw_label =
-        cmark_chunk_dup(&subj->input, startpos + 1, subj->pos - (startpos + 1));
+        cmark_chunk_dup(&subj->input, position, subj->pos - position);
     cmark_chunk_trim(raw_label);
     advance(subj); // advance past ]
     return 1;
@@ -1089,6 +1105,7 @@ static cmark_node *handle_close_bracket_attribute(cmark_parser *parser, subject
   cmark_chunk raw_label;
   int found_label;
   cmark_node *tmp, *tmpnext;
+  cmark_reference *ref = NULL;
   bool isAttributesNode = false;
 
   // ^name[content](attributes)
@@ -1112,6 +1129,19 @@ static cmark_node *handle_close_bracket_attribute(cmark_parser *parser, subject
       }
     }
   }
+  
+  // If we can't match direct link, look for [link label] that matches in refmap
+  raw_label = cmark_chunk_literal("");
+  found_label = link_label(subj, &raw_label, false);
+  if (found_label) {
+    ref = (cmark_reference *)cmark_map_lookup(subj->refmap, &raw_label);
+    cmark_chunk_free(subj->mem, &raw_label);
+    
+    if (ref && ref->is_attributes_reference) {
+      isAttributesNode = true;
+      attributes = chunk_clone(subj->mem, &ref->attributes);
+    }
+  }
 
   if (!isAttributesNode) {
     // The current node can't be parsed as attribute node, turn it to a TEXT node instead.
@@ -1220,7 +1250,7 @@ static cmark_node *handle_close_bracket(cmark_parser *parser, subject *subj) {
   // Next, look for a following [link label] that matches in refmap.
   // skip spaces
   raw_label = cmark_chunk_literal("");
-  found_label = link_label(subj, &raw_label);
+  found_label = link_label(subj, &raw_label, false);
   if (!found_label) {
     // If we have a shortcut reference link, back up
     // to before the spacse we skipped.
@@ -1239,7 +1269,7 @@ static cmark_node *handle_close_bracket(cmark_parser *parser, subject *subj) {
     cmark_chunk_free(subj->mem, &raw_label);
   }
 
-  if (ref != NULL) { // found
+  if (ref != NULL && !ref->is_attributes_reference) { // found
     url = chunk_clone(subj->mem, &ref->url);
     title = chunk_clone(subj->mem, &ref->title);
     goto match;
@@ -1568,7 +1598,7 @@ bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
   subject_from_buf(mem, -1, 0, &subj, input, NULL);
 
   // parse label:
-  if (!link_label(&subj, &lab) || lab.len == 0)
+  if (!link_label(&subj, &lab, false) || lab.len == 0)
     return 0;
 
   // colon:
@@ -1616,6 +1646,56 @@ bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
   return subj.pos;
 }
 
+bufsize_t cmark_parse_reference_attributes_inline(cmark_mem *mem, cmark_chunk *input,
+                                                  cmark_map *refmap) {
+  subject subj;
+  
+  cmark_chunk lab;
+  cmark_chunk attributes;
+  
+  bufsize_t matchlen = 0;
+  unsigned char c;
+  
+  subject_from_buf(mem, -1, 0, &subj, input, NULL);
+  
+  // parse attribute label:
+  if (!link_label(&subj, &lab, true) || lab.len == 0) {
+    return 0;
+  }
+  
+  // Colon:
+  if (peek_char(&subj) == ':') {
+    advance(&subj);
+  } else {
+    return 0;
+  }
+  
+  // parse attributes
+  spnl(&subj);
+  // read until next newline
+  bufsize_t startpos = subj.pos;
+  while ((c = peek_char(&subj)) && !S_is_line_end_char(c)) {
+    advance(&subj);
+    matchlen++;
+  }
+  
+  if (matchlen == 0) {
+    return 0;
+  }
+  
+  attributes = cmark_chunk_dup(&subj.input, startpos, matchlen);
+  
+  // parse final spaces and newline:
+  skip_spaces(&subj);
+  if (!skip_line_end(&subj)) {
+    return 0;
+  }
+  
+  // insert reference into refmap
+  cmark_reference_create_attributes(refmap, &lab, &attributes);
+  return subj.pos;
+}
+
 unsigned char cmark_inline_parser_peek_char(cmark_inline_parser *parser) {
   return peek_char(parser);
 }

src/references.c

@@ -11,6 +11,7 @@ static void reference_free(cmark_map *map, cmark_map_entry *_ref) {
     mem->free(ref->entry.label);
     cmark_chunk_free(mem, &ref->url);
     cmark_chunk_free(mem, &ref->title);
+    cmark_chunk_free(mem, &ref->attributes);
     mem->free(ref);
   }
 }
@@ -28,15 +29,41 @@ void cmark_reference_create(cmark_map *map, cmark_chunk *label,
 
   ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref));
   ref->entry.label = reflabel;
+  ref->is_attributes_reference = false;
   ref->url = cmark_clean_url(map->mem, url);
   ref->title = cmark_clean_title(map->mem, title);
+  ref->attributes = cmark_chunk_literal("");
   ref->entry.age = map->size;
   ref->entry.next = map->refs;
 
   map->refs = (cmark_map_entry *)ref;
   map->size++;
 }
 
+void cmark_reference_create_attributes(cmark_map *map, cmark_chunk *label,
+                                       cmark_chunk *attributes) {
+  cmark_reference *ref;
+  unsigned char *reflabel = normalize_map_label(map->mem, label);
+
+  /* empty reference name, or composed from only whitespace */
+  if (reflabel == NULL)
+    return;
+
+  assert(map->sorted == NULL);
+
+  ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref));
+  ref->entry.label = reflabel;
+  ref->is_attributes_reference = true;
+  ref->url = cmark_chunk_literal("");
+  ref->title = cmark_chunk_literal("");
+  ref->attributes = cmark_clean_attributes(map->mem, attributes);
+  ref->entry.age = map->size;
+  ref->entry.next = map->refs;
+  
+  map->refs = (cmark_map_entry *)ref;
+  map->size++;
+}
+
 cmark_map *cmark_reference_map_new(cmark_mem *mem) {
   return cmark_map_new(mem, reference_free);
 }