class CommonMarker::Node
Public Class Methods
Internal: Parses a Markdown string into an HTML string.
static VALUE rb_markdown_to_html(VALUE self, VALUE rb_text, VALUE rb_options, VALUE rb_extensions) { char *str, *html; int len; cmark_parser *parser; cmark_node *doc; Check_Type(rb_text, T_STRING); Check_Type(rb_options, T_FIXNUM); parser = prepare_parser(rb_options, rb_extensions, cmark_get_arena_mem_allocator()); str = (char *)RSTRING_PTR(rb_text); len = RSTRING_LEN(rb_text); cmark_parser_feed(parser, str, len); doc = cmark_parser_finish(parser); if (doc == NULL) { cmark_arena_reset(); rb_raise(rb_mNodeError, "error parsing document"); } cmark_mem *default_mem = cmark_get_default_mem_allocator(); html = cmark_render_html_with_mem(doc, FIX2INT(rb_options), parser->syntax_extensions, default_mem); cmark_arena_reset(); VALUE ruby_html = rb_str_new2(html); default_mem->free(html); return ruby_html; }
Internal: Creates a node based on a node type.
type - A {Symbol} representing the node to be created. Must be one of the following:
-
`:document`
-
`:blockquote`
-
`:list`
-
`:list_item`
-
`:code_block`
-
`:html`
-
`:paragraph`
-
`:header`
-
`:hrule`
-
`:text`
-
`:softbreak`
-
`:linebreak`
-
`:code`
-
`:inline_html`
-
`:emph`
-
`:strong`
-
`:link`
-
`:image`
static VALUE rb_node_new(VALUE self, VALUE type) { cmark_node_type node_type = 0; cmark_node *node; Check_Type(type, T_SYMBOL); if (type == sym_document) node_type = CMARK_NODE_DOCUMENT; else if (type == sym_blockquote) node_type = CMARK_NODE_BLOCK_QUOTE; else if (type == sym_list) node_type = CMARK_NODE_LIST; else if (type == sym_list_item) node_type = CMARK_NODE_ITEM; else if (type == sym_code_block) node_type = CMARK_NODE_CODE_BLOCK; else if (type == sym_html) node_type = CMARK_NODE_HTML; else if (type == sym_paragraph) node_type = CMARK_NODE_PARAGRAPH; else if (type == sym_header) node_type = CMARK_NODE_HEADER; else if (type == sym_hrule) node_type = CMARK_NODE_HRULE; else if (type == sym_text) node_type = CMARK_NODE_TEXT; else if (type == sym_softbreak) node_type = CMARK_NODE_SOFTBREAK; else if (type == sym_linebreak) node_type = CMARK_NODE_LINEBREAK; else if (type == sym_code) node_type = CMARK_NODE_CODE; else if (type == sym_inline_html) node_type = CMARK_NODE_INLINE_HTML; else if (type == sym_emph) node_type = CMARK_NODE_EMPH; else if (type == sym_strong) node_type = CMARK_NODE_STRONG; else if (type == sym_link) node_type = CMARK_NODE_LINK; else if (type == sym_image) node_type = CMARK_NODE_IMAGE; else if (type == sym_footnote_reference) node_type = CMARK_NODE_FOOTNOTE_REFERENCE; else if (type == sym_footnote_definition) node_type = CMARK_NODE_FOOTNOTE_DEFINITION; else rb_raise(rb_mNodeError, "invalid node of type %d", node_type); node = cmark_node_new(node_type); if (node == NULL) { rb_raise(rb_mNodeError, "could not create node of type %d", node_type); } return rb_node_to_value(node); }
Internal: Parses a Markdown string into a document.
static VALUE rb_parse_document(VALUE self, VALUE rb_text, VALUE rb_len, VALUE rb_options, VALUE rb_extensions) { char *text; int len, options; cmark_parser *parser; cmark_node *doc; Check_Type(rb_text, T_STRING); Check_Type(rb_len, T_FIXNUM); Check_Type(rb_options, T_FIXNUM); parser = prepare_parser(rb_options, rb_extensions, cmark_get_default_mem_allocator()); text = (char *)RSTRING_PTR(rb_text); len = FIX2INT(rb_len); options = FIX2INT(rb_options); cmark_parser_feed(parser, text, len); doc = cmark_parser_finish(parser); if (doc == NULL) { rb_raise(rb_mNodeError, "error parsing document"); } cmark_parser_free(parser); return rb_node_to_value(doc); }
Public Instance Methods
Internal: Convert the node to a CommonMark string.
Returns a {String}.
static VALUE rb_render_commonmark(int argc, VALUE *argv, VALUE self) { VALUE rb_options, rb_width; rb_scan_args(argc, argv, "11", &rb_options, &rb_width); int width = 120; if (!NIL_P(rb_width)) { Check_Type(rb_width, T_FIXNUM); width = FIX2INT(rb_width); } int options; cmark_node *node; Check_Type(rb_options, T_FIXNUM); options = FIX2INT(rb_options); Data_Get_Struct(self, cmark_node, node); char *cmark = cmark_render_commonmark(node, options, width); VALUE ruby_cmark = rb_str_new2(cmark); free(cmark); return ruby_cmark; }
Internal: Convert the node to an HTML string.
Returns a {String}.
static VALUE rb_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) { int options, extensions_len; VALUE rb_ext_name; int i; cmark_node *node; cmark_llist *extensions = NULL; cmark_mem *mem = cmark_get_default_mem_allocator(); Check_Type(rb_options, T_FIXNUM); Check_Type(rb_extensions, T_ARRAY); options = FIX2INT(rb_options); extensions_len = RARRAY_LEN(rb_extensions); Data_Get_Struct(self, cmark_node, node); for (i = 0; i < extensions_len; ++i) { rb_ext_name = RARRAY_PTR(rb_extensions)[i]; if (!SYMBOL_P(rb_ext_name)) { cmark_llist_free(mem, extensions); rb_raise(rb_eTypeError, "extension names should be Symbols; got a %"PRIsVALUE"", rb_obj_class(rb_ext_name)); } cmark_syntax_extension *syntax_extension = cmark_find_syntax_extension(rb_id2name(SYM2ID(rb_ext_name))); if (!syntax_extension) { cmark_llist_free(mem, extensions); rb_raise(rb_eArgError, "extension %s not found\n", rb_id2name(SYM2ID(rb_ext_name))); } extensions = cmark_llist_append(mem, extensions, syntax_extension); } char *html = cmark_render_html(node, options, extensions); VALUE ruby_html = rb_str_new2(html); cmark_llist_free(mem, extensions); free(html); return ruby_html; }
Internal: Convert the node to a plain textstring.
Returns a {String}.
static VALUE rb_render_plaintext(int argc, VALUE *argv, VALUE self) { VALUE rb_options, rb_width; rb_scan_args(argc, argv, "11", &rb_options, &rb_width); int width = 120; if (!NIL_P(rb_width)) { Check_Type(rb_width, T_FIXNUM); width = FIX2INT(rb_width); } int options; cmark_node *node; Check_Type(rb_options, T_FIXNUM); options = FIX2INT(rb_options); Data_Get_Struct(self, cmark_node, node); char *text = cmark_render_plaintext(node, options, width); VALUE ruby_text = rb_str_new2(text); free(text); return ruby_text; }
Public: Inserts a node as the last child of the current node.
child - A child {Node} to insert.
Returns `true` if successful. Raises NodeError if the node can't be inserted.
static VALUE rb_node_append_child(VALUE self, VALUE child) { cmark_node *node1, *node2; Data_Get_Struct(self, cmark_node, node1); Data_Get_Struct(child, cmark_node, node2); if (!cmark_node_append_child(node1, node2)) { rb_raise(rb_mNodeError, "could not append child"); } rb_parent_added(child); return Qtrue; }
Internal: Unlinks the node from the tree (fixing pointers in parents and siblings appropriately).
static VALUE rb_node_unlink(VALUE self) { cmark_node *node; Data_Get_Struct(self, cmark_node, node); cmark_node_unlink(node); rb_parent_removed(self); return Qnil; }
Public: Iterate over the children (if any) of the current pointer.
# File lib/commonmarker/node.rb, line 54 def each(&block) return enum_for(:each) unless block_given? child = first_child while child nextchild = child.next yield child child = nextchild end end
Deprecated: Please use `each` instead
# File lib/commonmarker/node.rb, line 66 def each_child(&block) warn '[DEPRECATION] `each_child` is deprecated. Please use `each` instead.' each(&block) end
Public: Gets the fence info of the current node (must be a `:code_block`).
Returns a {String} representing the fence info. Raises a NodeError if the fence info can't be retrieved.
static VALUE rb_node_get_fence_info(VALUE self) { const char *fence_info; cmark_node *node; Data_Get_Struct(self, cmark_node, node); fence_info = cmark_node_get_fence_info(node); if (fence_info == NULL) { rb_raise(rb_mNodeError, "could not get fence_info"); } return rb_str_new2(fence_info); }
Public: Sets the fence info of the current node (must be a `:code_block`).
info - A {String} representing the new fence info
Raises a NodeError if the fence info can't be set.
static VALUE rb_node_set_fence_info(VALUE self, VALUE info) { char *text; cmark_node *node; Check_Type(info, T_STRING); Data_Get_Struct(self, cmark_node, node); text = StringValueCStr(info); if (!cmark_node_set_fence_info(node, text)) { rb_raise(rb_mNodeError, "could not set fence_info"); } return Qnil; }
Public: Fetches the first child of the node.
Returns a {Node} if a child exists, `nil` otherise.
static VALUE rb_node_first_child(VALUE self) { cmark_node *node, *child; Data_Get_Struct(self, cmark_node, node); child = cmark_node_first_child(node); return rb_node_to_value(child); }
Public: Gets the header level of the current node (must be a `:header`).
Returns a {Number} representing the header level. Raises a NodeError if the header level can't be retrieved.
static VALUE rb_node_get_header_level(VALUE self) { int header_level; cmark_node *node; Data_Get_Struct(self, cmark_node, node); header_level = cmark_node_get_header_level(node); if (header_level == 0) { rb_raise(rb_mNodeError, "could not get header_level"); } return INT2NUM(header_level); }
Public: Sets the header level of the current node (must be a `:header`).
level - A {Number} representing the new header level
Raises a NodeError if the header level can't be set.
static VALUE rb_node_set_header_level(VALUE self, VALUE level) { int l; cmark_node *node; Check_Type(level, T_FIXNUM); Data_Get_Struct(self, cmark_node, node); l = FIX2INT(level); if (!cmark_node_set_header_level(node, l)) { rb_raise(rb_mNodeError, "could not set header_level"); } return Qnil; }
Internal: Escapes href URLs safely.
static VALUE rb_html_escape_href(VALUE self, VALUE rb_text) { char *result; cmark_node *node; Check_Type(rb_text, T_STRING); Data_Get_Struct(self, cmark_node, node); cmark_mem *mem = cmark_node_mem(node); cmark_strbuf buf = CMARK_BUF_INIT(mem); if (houdini_escape_href(&buf, (const uint8_t *)RSTRING_PTR(rb_text), RSTRING_LEN(rb_text))) { result = (char *)cmark_strbuf_detach(&buf); return rb_str_new2(result); } return rb_text; }
Internal: Escapes HTML content safely.
static VALUE rb_html_escape_html(VALUE self, VALUE rb_text) { char *result; cmark_node *node; Check_Type(rb_text, T_STRING); Data_Get_Struct(self, cmark_node, node); cmark_mem *mem = cmark_node_mem(node); cmark_strbuf buf = CMARK_BUF_INIT(mem); if (houdini_escape_html0(&buf, (const uint8_t *)RSTRING_PTR(rb_text), RSTRING_LEN(rb_text), 0)) { result = (char *)cmark_strbuf_detach(&buf); return rb_str_new2(result); } return rb_text; }
Public: Inserts a node as a sibling after the current node.
sibling - A sibling {Node} to insert.
Returns `true` if successful. Raises NodeError if the node can't be inserted.
static VALUE rb_node_insert_after(VALUE self, VALUE sibling) { cmark_node *node1, *node2; Data_Get_Struct(self, cmark_node, node1); Data_Get_Struct(sibling, cmark_node, node2); if (!cmark_node_insert_after(node1, node2)) { rb_raise(rb_mNodeError, "could not insert after"); } rb_parent_added(sibling); return Qtrue; }
Public: Inserts a node as a sibling before the current node.
sibling - A sibling {Node} to insert.
Returns `true` if successful. Raises NodeError if the node can't be inserted.
static VALUE rb_node_insert_before(VALUE self, VALUE sibling) { cmark_node *node1, *node2; Data_Get_Struct(self, cmark_node, node1); Data_Get_Struct(sibling, cmark_node, node2); if (!cmark_node_insert_before(node1, node2)) { rb_raise(rb_mNodeError, "could not insert before"); } rb_parent_added(sibling); return Qtrue; }
Public: Fetches the first child of the current node.
Returns a {Node} if a child exists, `nil` otherise.
static VALUE rb_node_last_child(VALUE self) { cmark_node *node, *child; Data_Get_Struct(self, cmark_node, node); child = cmark_node_last_child(node); return rb_node_to_value(child); }
Public: Gets the starting number the current node (must be an `:ordered_list`).
Returns a {Number} representing the starting number. Raises a NodeError if the starting number can't be retrieved.
static VALUE rb_node_get_list_start(VALUE self) { cmark_node *node; Data_Get_Struct(self, cmark_node, node); if (cmark_node_get_type(node) != CMARK_NODE_LIST || cmark_node_get_list_type(node) != CMARK_ORDERED_LIST) { rb_raise(rb_mNodeError, "can't get list_start for non-ordered list %d", cmark_node_get_list_type(node)); } return INT2NUM(cmark_node_get_list_start(node)); }
Public: Sets the starting number of the current node (must be an `:ordered_list`).
level - A {Number} representing the new starting number
Raises a NodeError if the starting number can't be set.
static VALUE rb_node_set_list_start(VALUE self, VALUE start) { int s; cmark_node *node; Check_Type(start, T_FIXNUM); Data_Get_Struct(self, cmark_node, node); s = FIX2INT(start); if (!cmark_node_set_list_start(node, s)) { rb_raise(rb_mNodeError, "could not set list_start"); } return Qnil; }
Public: Gets the tight status the current node (must be a `:list`).
Returns a `true` if the list is tight, `false` otherwise. Raises a NodeError if the starting number can't be retrieved.
static VALUE rb_node_get_list_tight(VALUE self) { int flag; cmark_node *node; Data_Get_Struct(self, cmark_node, node); if (cmark_node_get_type(node) != CMARK_NODE_LIST) { rb_raise(rb_mNodeError, "can't get list_tight for non-list"); } flag = cmark_node_get_list_tight(node); return flag ? Qtrue : Qfalse; }
Public: Sets the tight status of the current node (must be a `:list`).
tight - A {Boolean} representing the new tightness
Raises a NodeError if the tightness can't be set.
static VALUE rb_node_set_list_tight(VALUE self, VALUE tight) { int t; cmark_node *node; Data_Get_Struct(self, cmark_node, node); t = RTEST(tight); if (!cmark_node_set_list_tight(node, t)) { rb_raise(rb_mNodeError, "could not set list_tight"); } return Qnil; }
Public: Gets the list type of the current node (must be a `:list`).
Returns a {Symbol}. Raises a NodeError if the title can't be retrieved.
static VALUE rb_node_get_list_type(VALUE self) { int list_type; cmark_node *node; VALUE symbol; Data_Get_Struct(self, cmark_node, node); list_type = cmark_node_get_list_type(node); if (list_type == CMARK_BULLET_LIST) { symbol = sym_bullet_list; } else if (list_type == CMARK_ORDERED_LIST) { symbol = sym_ordered_list; } else { rb_raise(rb_mNodeError, "could not get list_type"); } return symbol; }
Public: Sets the list type of the current node (must be a `:list`).
level - A {Symbol} representing the new list type
Raises a NodeError if the list type can't be set.
static VALUE rb_node_set_list_type(VALUE self, VALUE list_type) { int type = 0; cmark_node *node; Check_Type(list_type, T_SYMBOL); Data_Get_Struct(self, cmark_node, node); if (list_type == sym_bullet_list) { type = CMARK_BULLET_LIST; } else if (list_type == sym_ordered_list) { type = CMARK_ORDERED_LIST; } else { rb_raise(rb_mNodeError, "invalid list_type"); } if (!cmark_node_set_list_type(node, type)) { rb_raise(rb_mNodeError, "could not set list_type"); } return Qnil; }
Public: Fetches the next sibling of the node.
Returns a {Node} if a sibling exists, `nil` otherwise.
static VALUE rb_node_next(VALUE self) { cmark_node *node, *next; Data_Get_Struct(self, cmark_node, node); next = cmark_node_next(node); return rb_node_to_value(next); }
Public: Fetches the parent of the current node.
Returns a {Node} if a parent exists, `nil` otherise.
static VALUE rb_node_parent(VALUE self) { cmark_node *node, *parent; Data_Get_Struct(self, cmark_node, node); parent = cmark_node_parent(node); return rb_node_to_value(parent); }
Public: Inserts a node as the first child of the current node.
child - A child {Node} to insert.
Returns `true` if successful. Raises NodeError if the node can't be inserted.
static VALUE rb_node_prepend_child(VALUE self, VALUE child) { cmark_node *node1, *node2; Data_Get_Struct(self, cmark_node, node1); Data_Get_Struct(child, cmark_node, node2); if (!cmark_node_prepend_child(node1, node2)) { rb_raise(rb_mNodeError, "could not prepend child"); } rb_parent_added(child); return Qtrue; }
Public: Fetches the previous sibling of the current node.
Returns a {Node} if a parent exists, `nil` otherise.
static VALUE rb_node_previous(VALUE self) { cmark_node *node, *previous; Data_Get_Struct(self, cmark_node, node); previous = cmark_node_previous(node); return rb_node_to_value(previous); }
Public: Fetches the sourcepos of the node.
Returns a {Hash} containing {Symbol} keys of the positions.
static VALUE rb_node_get_sourcepos(VALUE self) { int start_line, start_column, end_line, end_column; VALUE result; cmark_node *node; Data_Get_Struct(self, cmark_node, node); start_line = cmark_node_get_start_line(node); start_column = cmark_node_get_start_column(node); end_line = cmark_node_get_end_line(node); end_column = cmark_node_get_end_column(node); result = rb_hash_new(); rb_hash_aset(result, CSTR2SYM("start_line"), INT2NUM(start_line)); rb_hash_aset(result, CSTR2SYM("start_column"), INT2NUM(start_column)); rb_hash_aset(result, CSTR2SYM("end_line"), INT2NUM(end_line)); rb_hash_aset(result, CSTR2SYM("end_column"), INT2NUM(end_column)); return result; }
Public: Fetch the string contents of the node.
Returns a {String}.
static VALUE rb_node_get_string_content(VALUE self) { const char *text; cmark_node *node; Data_Get_Struct(self, cmark_node, node); text = cmark_node_get_literal(node); if (text == NULL) { rb_raise(rb_mNodeError, "could not get string content"); } return encode_utf8_string(text); }
Public: Sets the string content of the node.
string - A {String} containing new content.
Raises NodeError if the string content can't be set.
static VALUE rb_node_set_string_content(VALUE self, VALUE s) { char *text; cmark_node *node; Check_Type(s, T_STRING); Data_Get_Struct(self, cmark_node, node); text = StringValueCStr(s); if (!cmark_node_set_literal(node, text)) { rb_raise(rb_mNodeError, "could not set string content"); } return Qnil; }
static VALUE rb_node_get_table_alignments(VALUE self) { uint16_t column_count, i; uint8_t *alignments; cmark_node *node; VALUE ary; Data_Get_Struct(self, cmark_node, node); column_count = cmarkextensions_get_table_columns(node); alignments = cmarkextensions_get_table_alignments(node); if (!column_count || !alignments) { rb_raise(rb_mNodeError, "could not get column_count or alignments"); } ary = rb_ary_new(); for (i = 0; i < column_count; ++i) { if (alignments[i] == 'l') rb_ary_push(ary, sym_left); else if (alignments[i] == 'c') rb_ary_push(ary, sym_center); else if (alignments[i] == 'r') rb_ary_push(ary, sym_right); else rb_ary_push(ary, Qnil); } return ary; }
Public: Gets the title of the current node (must be a `:link` or `:image`).
Returns a {String}. Raises a NodeError if the title can't be retrieved.
static VALUE rb_node_get_title(VALUE self) { const char *text; cmark_node *node; Data_Get_Struct(self, cmark_node, node); text = cmark_node_get_title(node); if (text == NULL) { rb_raise(rb_mNodeError, "could not get title"); } return rb_str_new2(text); }
Public: Sets the title of the current node (must be a `:link` or `:image`).
title - A {String} representing the new title
Raises a NodeError if the title can't be set.
static VALUE rb_node_set_title(VALUE self, VALUE title) { char *text; cmark_node *node; Check_Type(title, T_STRING); Data_Get_Struct(self, cmark_node, node); text = StringValueCStr(title); if (!cmark_node_set_title(node, text)) { rb_raise(rb_mNodeError, "could not set title"); } return Qnil; }
Public: Convert the node to a CommonMark string.
options - A {Symbol} or {Array of Symbol}s indicating the render options width - Column to wrap the output at
Returns a {String}.
# File lib/commonmarker/node.rb, line 37 def to_commonmark(options = :DEFAULT, width = 120) opts = Config.process_options(options, :render) _render_commonmark(opts, width).force_encoding('utf-8') end
Public: Convert the node to an HTML string.
options - A {Symbol} or {Array of Symbol}s indicating the render options extensions - An {Array of Symbol}s indicating the extensions to use
Returns a {String}.
# File lib/commonmarker/node.rb, line 26 def to_html(options = :DEFAULT, extensions = []) opts = Config.process_options(options, :render) _render_html(opts, extensions).force_encoding('utf-8') end
Public: Convert the node to a plain text string.
options - A {Symbol} or {Array of Symbol}s indicating the render options width - Column to wrap the output at
Returns a {String}.
# File lib/commonmarker/node.rb, line 48 def to_plaintext(options = :DEFAULT, width = 120) opts = Config.process_options(options, :render) _render_plaintext(opts, width).force_encoding('utf-8') end
Public: Fetches the list type of the node.
Returns a {Symbol} representing the node's type.
static VALUE rb_node_get_type(VALUE self) { int node_type; cmark_node *node; VALUE symbol; const char *s; Data_Get_Struct(self, cmark_node, node); node_type = cmark_node_get_type(node); symbol = Qnil; switch (node_type) { case CMARK_NODE_DOCUMENT: symbol = sym_document; break; case CMARK_NODE_BLOCK_QUOTE: symbol = sym_blockquote; break; case CMARK_NODE_LIST: symbol = sym_list; break; case CMARK_NODE_ITEM: symbol = sym_list_item; break; case CMARK_NODE_CODE_BLOCK: symbol = sym_code_block; break; case CMARK_NODE_HTML: symbol = sym_html; break; case CMARK_NODE_PARAGRAPH: symbol = sym_paragraph; break; case CMARK_NODE_HEADER: symbol = sym_header; break; case CMARK_NODE_HRULE: symbol = sym_hrule; break; case CMARK_NODE_TEXT: symbol = sym_text; break; case CMARK_NODE_SOFTBREAK: symbol = sym_softbreak; break; case CMARK_NODE_LINEBREAK: symbol = sym_linebreak; break; case CMARK_NODE_CODE: symbol = sym_code; break; case CMARK_NODE_INLINE_HTML: symbol = sym_inline_html; break; case CMARK_NODE_EMPH: symbol = sym_emph; break; case CMARK_NODE_STRONG: symbol = sym_strong; break; case CMARK_NODE_LINK: symbol = sym_link; break; case CMARK_NODE_IMAGE: symbol = sym_image; break; case CMARK_NODE_FOOTNOTE_REFERENCE: symbol = sym_footnote_reference; break; case CMARK_NODE_FOOTNOTE_DEFINITION: symbol = sym_footnote_definition; break; default: if (node->extension) { s = node->extension->get_type_string_func(node->extension, node); return ID2SYM(rb_intern(s)); } rb_raise(rb_mNodeError, "invalid node type %d", node_type); } return symbol; }
Public: Returns the type of the current pointer as a string.
Returns a {String}.
static VALUE rb_node_get_type_string(VALUE self) { cmark_node *node; Data_Get_Struct(self, cmark_node, node); return rb_str_new2(cmark_node_get_type_string(node)); }
Public: Gets the URL of the current node (must be a `:link` or `:image`).
Returns a {String}. Raises a NodeError if the URL can't be retrieved.
static VALUE rb_node_get_url(VALUE self) { const char *text; cmark_node *node; Data_Get_Struct(self, cmark_node, node); text = cmark_node_get_url(node); if (text == NULL) { rb_raise(rb_mNodeError, "could not get url"); } return rb_str_new2(text); }
Public: Sets the URL of the current node (must be a `:link` or `:image`).
url - A {String} representing the new URL
Raises a NodeError if the URL can't be set.
static VALUE rb_node_set_url(VALUE self, VALUE url) { cmark_node *node; char *text; Check_Type(url, T_STRING); Data_Get_Struct(self, cmark_node, node); text = StringValueCStr(url); if (!cmark_node_set_url(node, text)) { rb_raise(rb_mNodeError, "could not set url"); } return Qnil; }
Public: An iterator that “walks the tree,” descending into children recursively.
blk - A {Proc} representing the action to take for each child
# File lib/commonmarker/node.rb, line 11 def walk(&block) return enum_for(:walk) unless block_given? yield self each do |child| child.walk(&block) end end