Class: CommonMarker::Node

Inherits:

Object

• Object
• CommonMarker::Node

Defined in:

lib/commonmarker.rb,
ext/commonmarker/commonmarker.c

Class Method Summary

• .html_escape_href(rb_text) ⇒ Object

  Internal: Escapes href URLs safely.

• .html_escape_html(rb_text) ⇒ Object

  Internal: Escapes HTML content safely.

• .markdown_to_html(rb_text, rb_options) ⇒ Object

  Internal: Parses a Markdown string into an HTML string.

• .new(type) ⇒ Object

  Internal: Creates a node based on a node type.

• .parse_document(rb_text, rb_len, rb_options) ⇒ Object

  Internal: Parses a Markdown string into a document.

Instance Method Summary

• #_render_html(rb_options) ⇒ Object

  Internal: Convert the node to an HTML string.

• #append_child(child) ⇒ Object

  Public: Inserts a node as the last child of the current node.

• #delete ⇒ Object

  Internal: Unlinks the node from the tree (fixing pointers in parents and siblings appropriately).

• #each_child ⇒ Object

  Internal: Iterate over the children (if any) of the current pointer.

• #fence_info ⇒ Object

  Public: Gets the fence info of the current node (must be a ‘:code_block`).

• #fence_info=(info) ⇒ Object

  Public: Sets the fence info of the current node (must be a ‘:code_block`).

• #first_child ⇒ Object

  Public: Fetches the first child of the node.

• #header_level ⇒ Object

  Public: Gets the header level of the current node (must be a ‘:header`).

• #header_level=(level) ⇒ Object

  Public: Sets the header level of the current node (must be a ‘:header`).

• #insert_after(sibling) ⇒ Object

  Public: Inserts a node as a sibling after the current node.

• #insert_before(sibling) ⇒ Object

  Public: Inserts a node as a sibling before the current node.

• #last_child ⇒ Object

  Public: Fetches the first child of the current node.

• #list_start ⇒ Object

  Public: Gets the starting number the current node (must be an ‘:ordered_list`).

• #list_start=(start) ⇒ Object

  Public: Sets the starting number of the current node (must be an ‘:ordered_list`).

• #list_tight ⇒ Object

  Public: Gets the tight status the current node (must be a ‘:list`).

• #list_tight=(tight) ⇒ Object

  Public: Sets the tight status of the current node (must be a ‘:list`).

• #list_type ⇒ Object

  Public: Gets the list type of the current node (must be a ‘:list`).

• #list_type=(list_type) ⇒ Object

  Public: Sets the list type of the current node (must be a ‘:list`).

• #next ⇒ Object

  Public: Fetches the next sibling of the node.

• #parent ⇒ Object

  Public: Fetches the parent of the current node.

• #prepend_child(child) ⇒ Object

  Public: Inserts a node as the first child of the current node.

• #previous ⇒ Object

  Public: Fetches the previous sibling of the current node.

• #sourcepos ⇒ Object

  Public: Fetches the sourcepos of the node.

• #string_content ⇒ Object

  Public: Fetch the string contents of the node.

• #string_content=(s) ⇒ Object

  Public: Sets the string content of the node.

• #title ⇒ Object

  Public: Gets the title of the current node (must be a ‘:link` or `:image`).

• #title=(title) ⇒ Object

  Public: Sets the title of the current node (must be a ‘:link` or `:image`).

• #to_html(options = :default) ⇒ Object

  Public: Convert the node to an HTML string.

• #type ⇒ Object

  Public: Fetches the list type of the node.

• #type_string ⇒ Object

  Public: Returns the type of the current pointer as a string.

• #url ⇒ Object

  Public: Gets the URL of the current node (must be a ‘:link` or `:image`).

• #url=(url) ⇒ Object

  Public: Sets the URL of the current node (must be a ‘:link` or `:image`).

• #walk {|_self| ... } ⇒ Object

  Public: An iterator that “walks the tree,” descending into children recursively.

Class Method Details

.html_escape_href(rb_text) ⇒ Object

Internal: Escapes href URLs safely.

# File 'ext/commonmarker/commonmarker.c', line 942

static VALUE
rb_html_escape_href(VALUE self, VALUE rb_text)
{
	char *result;
	cmark_strbuf buf = GH_BUF_INIT;

	Check_Type(rb_text, T_STRING);

	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;

}

.html_escape_html(rb_text) ⇒ Object

Internal: Escapes HTML content safely.

# File 'ext/commonmarker/commonmarker.c', line 960

static VALUE
rb_html_escape_html(VALUE self, VALUE rb_text)
{
	char *result;
	cmark_strbuf buf = GH_BUF_INIT;

	Check_Type(rb_text, T_STRING);

	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;
}

.markdown_to_html(rb_text, rb_options) ⇒ Object

Internal: Parses a Markdown string into an HTML string.

# File 'ext/commonmarker/commonmarker.c', line 115

static VALUE
rb_markdown_to_html(VALUE self, VALUE rb_text, VALUE rb_options)
{
	char *str;
	int len, options;

	Check_Type(rb_text, T_STRING);
	Check_Type(rb_options, T_FIXNUM);

	str = (char *)RSTRING_PTR(rb_text);
	len = RSTRING_LEN(rb_text);
	options = FIX2INT(rb_options);

	return rb_str_new2(cmark_markdown_to_html(str, len, options));
}

.new(type) ⇒ Object

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`

# File 'ext/commonmarker/commonmarker.c', line 154

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
		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);
}

.parse_document(rb_text, rb_len, rb_options) ⇒ Object

Internal: Parses a Markdown string into a document.

# File 'ext/commonmarker/commonmarker.c', line 213

static VALUE
rb_parse_document(VALUE self, VALUE rb_text, VALUE rb_len, VALUE rb_options)
{
	char *text;
	int len, options;
	cmark_node *doc;
	Check_Type(rb_text, T_STRING);
	Check_Type(rb_len, T_FIXNUM);
	Check_Type(rb_options, T_FIXNUM);

	text = (char *)RSTRING_PTR(rb_text);
	len = FIX2INT(rb_len);
	options = FIX2INT(rb_options);

	doc = cmark_parse_document(text, len, options);
	if (doc == NULL) {
		rb_raise(rb_mNodeError, "error parsing document");
	}

	return rb_node_to_value(doc);
}

Instance Method Details

#_render_html(rb_options) ⇒ Object

Internal: Convert the node to an HTML string.

Returns a String.

# File 'ext/commonmarker/commonmarker.c', line 476

static VALUE
rb_render_html(VALUE n, VALUE rb_options)
{
	int options;
	cmark_node *node;
	Check_Type(rb_options, T_FIXNUM);

	options = FIX2INT(rb_options);

	Data_Get_Struct(n, cmark_node, node);

	return rb_str_new2(cmark_render_html(node, options));
}

#append_child(child) ⇒ Object

Public: Inserts a node as the last child of the current node.

child - A child CommonMarker::Node to insert.

Returns ‘true` if successful. Raises NodeError if the node can’t be inserted.

# File 'ext/commonmarker/commonmarker.c', line 548

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;
}

#delete ⇒ Object

Internal: Unlinks the node from the tree (fixing pointers in parents and siblings appropriately).

# File 'ext/commonmarker/commonmarker.c', line 404

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;
}

#each_child ⇒ Object

Internal: Iterate over the children (if any) of the current pointer.

# File 'lib/commonmarker.rb', line 62

def each_child
  child = first_child
  while child
    nextchild = child.next
    yield child
    child = nextchild
  end
end

#fence_info ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 901

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);
}

#fence_info=(info) ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 924

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;
}

#first_child ⇒ Object

Public: Fetches the first child of the node.

Returns a CommonMarker::Node if a child exists, ‘nil` otherise.

# File 'ext/commonmarker/commonmarker.c', line 421

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);
}

#header_level ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 706

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);
}

#header_level=(level) ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 729

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;
}

#insert_after(sibling) ⇒ Object

Public: Inserts a node as a sibling after the current node.

sibling - A sibling CommonMarker::Node to insert.

Returns ‘true` if successful. Raises NodeError if the node can’t be inserted.

# File 'ext/commonmarker/commonmarker.c', line 498

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;
}

#insert_before(sibling) ⇒ Object

Public: Inserts a node as a sibling before the current node.

sibling - A sibling CommonMarker::Node to insert.

Returns ‘true` if successful. Raises NodeError if the node can’t be inserted.

# File 'ext/commonmarker/commonmarker.c', line 455

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;
}

#last_child ⇒ Object

Public: Fetches the first child of the current node.

Returns a CommonMarker::Node if a child exists, ‘nil` otherise.

# File 'ext/commonmarker/commonmarker.c', line 569

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);
}

#list_start ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 810

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));
}

#list_start=(start) ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 833

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;
}

#list_tight ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 856

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;
}

#list_tight=(tight) ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 880

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;
}

#list_type ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 752

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;
}

#list_type=(list_type) ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 780

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;
}

#next ⇒ Object

Public: Fetches the next sibling of the node.

Returns a CommonMarker::Node if a sibling exists, ‘nil` otherwise.

# File 'ext/commonmarker/commonmarker.c', line 436

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);
}

#parent ⇒ Object

Public: Fetches the parent of the current node.

Returns a CommonMarker::Node if a parent exists, ‘nil` otherise.

# File 'ext/commonmarker/commonmarker.c', line 584

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);
}

#prepend_child(child) ⇒ Object

Public: Inserts a node as the first child of the current node.

child - A child CommonMarker::Node to insert.

Returns ‘true` if successful. Raises NodeError if the node can’t be inserted.

# File 'ext/commonmarker/commonmarker.c', line 523

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;
}

#previous ⇒ Object

Public: Fetches the previous sibling of the current node.

Returns a CommonMarker::Node if a parent exists, ‘nil` otherise.

# File 'ext/commonmarker/commonmarker.c', line 599

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);
}

#sourcepos ⇒ Object

Public: Fetches the sourcepos of the node.

Returns a Hash containing Symbol keys of the positions.

# File 'ext/commonmarker/commonmarker.c', line 363

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;
}

#string_content ⇒ Object

Public: Fetch the string contents of the node.

Returns a String.

# File 'ext/commonmarker/commonmarker.c', line 240

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 rb_str_new2(text);
}

#string_content=(s) ⇒ Object

Public: Sets the string content of the node.

string - A String containing new content.

Raises NodeError if the string content can’t be set.

# File 'ext/commonmarker/commonmarker.c', line 262

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;
}

#title ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 661

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);
}

#title=(title) ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 683

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;
}

#to_html(options = :default) ⇒ Object

Public: Convert the node to an HTML string.

options - A Symbol or of Symbols indicating the render options

Returns a String.

# File 'lib/commonmarker.rb', line 56

def to_html(options = :default)
  opts = Config.process_options(options, :render)
  _render_html(opts).force_encoding('utf-8')
end

#type ⇒ Object

Public: Fetches the list type of the node.

Returns a Symbol representing the node’s type.

# File 'ext/commonmarker/commonmarker.c', line 284

static VALUE
rb_node_get_type(VALUE self)
{
	int node_type;
	cmark_node *node;
	VALUE symbol;

	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;
	default:
		rb_raise(rb_mNodeError, "invalid node type %d", node_type);
	}

	return symbol;
}

#type_string ⇒ Object

Public: Returns the type of the current pointer as a string.

Returns a String.

# File 'ext/commonmarker/commonmarker.c', line 391

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));
}

#url ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 616

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);
}

#url=(url) ⇒ Object

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.

# File 'ext/commonmarker/commonmarker.c', line 638

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;
}

#walk {|_self| ... } ⇒ Object

Public: An iterator that “walks the tree,” descending into children recursively.

blk - A Proc representing the action to take for each child

Yields:

• (_self)

Yield Parameters:

• _self (CommonMarker::Node) —

  the object that the method was called on

# File 'lib/commonmarker.rb', line 44

def walk(&blk)
  yield self
  each_child do |child|
    child.walk(&blk)
  end
end