Class: Markly::Node

Inherits:

Object

• Object
• Markly::Node

Includes:

Enumerable, Inspect

Defined in:

lib/markly/node.rb,
lib/markly/node/inspect.rb,
ext/markly/markly.c

Overview

Represents a node in a parsed Markdown document tree.

Defined Under Namespace

Modules: Inspect

Constant Summary

Constants included from Inspect

Inspect::PP_INDENT_SIZE

Class Method Summary

• .new(type) ⇒ Object

Instance Method Summary

• #_render_commonmark(*args) ⇒ Object
• #_render_html(rb_options, rb_extensions) ⇒ Object
• #_render_plaintext(*args) ⇒ Object
• #append_after(node) ⇒ Object

  Append the given node after the current node.

• #append_before(node) ⇒ Object

  Append the given node before the current node.

• #append_child(child) ⇒ Object
• #code_info ⇒ Object
• #code_info=(info) ⇒ Object
• #code_language ⇒ Object

  Return the language identifier from the code info string.

• #delete ⇒ Object
• #delete_until ⇒ Object

  Delete all nodes until the block returns true.

• #dup ⇒ Object

  Duplicate the current node and all its children.

• #each ⇒ Object

  Iterate over the direct children of this node.

• #extract_children ⇒ Object

  Extract the children as a fragment.

• #fence ⇒ Object
• #fence_info ⇒ Object
• #fence_info=(info) ⇒ Object
• #find_header(title) ⇒ Object

  Finds a direct child header with the given text.

• #first_child ⇒ Object
• #header_level ⇒ Object
• #header_level=(level) ⇒ Object
• #html_escape_href(rb_text) ⇒ Object
• #html_escape_html(rb_text) ⇒ Object
• #insert_after(sibling) ⇒ Object
• #insert_before(sibling) ⇒ Object
• #last_child ⇒ Object
• #list_start ⇒ Object
• #list_start=(start) ⇒ Object
• #list_tight ⇒ Object
• #list_tight=(tight) ⇒ Object
• #list_type ⇒ Object
• #list_type=(list_type) ⇒ Object
• #next ⇒ Object
• #next_header ⇒ Object (also: #next_heading)

  Finds the next sibling header.

• #parent ⇒ Object
• #parent_footnote_def ⇒ Object
• #prepend_child(child) ⇒ Object
• #previous ⇒ Object
• #replace(other) ⇒ Object
• #replace_section(new_node, replace_header: true, remove_subsections: true) ⇒ Object

  Replace a section (header + content) with a new node.

• #source_position ⇒ Object
• #string_content ⇒ Object
• #string_content=(s) ⇒ Object
• #table_alignments ⇒ Object
• #tasklist_item_checked=(item_checked) ⇒ Object
• #tasklist_item_checked? ⇒ Boolean
• #title ⇒ Object
• #title=(title) ⇒ Object
• #to_commonmark(flags: DEFAULT, width: 0) ⇒ Object (also: #to_markdown)

  Convert the node to a CommonMark string.

• #to_html(flags: DEFAULT, extensions: []) ⇒ Object

  Convert the node to an HTML string.

• #to_plaintext(flags: DEFAULT, width: 0) ⇒ Object

  Convert the node to a plain-text string.

• #type ⇒ Object
• #type_string ⇒ Object
• #url ⇒ Object
• #url=(url) ⇒ Object
• #walk {|_self| ... } ⇒ Object

  Walk the node tree recursively.

Methods included from Inspect

#inspect, #pretty_print

Class Method Details

.new(type) ⇒ Object

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

static VALUE Markly_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_custom_block)
		node_type = CMARK_NODE_CUSTOM_BLOCK;
	else if (type == sym_custom_inline)
		node_type = CMARK_NODE_CUSTOM_INLINE;
	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(Markly_Error, "invalid node of type %d", node_type);

	node = cmark_node_new(node_type);
	if (node == NULL) {
		rb_raise(Markly_Error, "could not create node of type %d", node_type);
	}

	return Markly_Node_wrap(node);
}

Instance Method Details

#_render_commonmark(*args) ⇒ Object

# File 'ext/markly/markly.c', line 581

static VALUE Markly_Node_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);
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	char *cmark = cmark_render_commonmark(node, options, width);
	VALUE ruby_cmark = rb_str_new2(cmark);
	free(cmark);

	return ruby_cmark;
}

#_render_html(rb_options, rb_extensions) ⇒ Object

# File 'ext/markly/markly.c', line 535

static VALUE Markly_Node_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) {
	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);

	int options = FIX2INT(rb_options);
	long extensions_len = RARRAY_LEN(rb_extensions);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, 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;
}

#_render_plaintext(*args) ⇒ Object

# File 'ext/markly/markly.c', line 609

static VALUE Markly_Node_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);
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	char *text = cmark_render_plaintext(node, options, width);
	VALUE ruby_text = rb_str_new2(text);
	free(text);

	return ruby_text;
}

#append_after(node) ⇒ Object

Append the given node after the current node.

It's okay to provide a document node, its children will be appended.

# File 'lib/markly/node.rb', line 163

def append_after(node)
	if node.type == :document
		node = node.first_child
	end
	
	current = self
	while node
		next_node = node.next
		current.insert_after(node)
		current = node
		node = next_node
	end
end

#append_before(node) ⇒ Object

Append the given node before the current node.

It's okay to provide a document node, its children will be appended.

# File 'lib/markly/node.rb', line 182

def append_before(node)
	if node.type == :document
		node = node.first_child
	end
	
	current = self
	while node
		next_node = node.next
		current.insert_before(node)
		node = next_node
	end
end

#append_child(child) ⇒ Object

# File 'ext/markly/markly.c', line 681

static VALUE Markly_Node_append_child(VALUE self, VALUE child) {
	cmark_node *node1, *node2;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node1);
	TypedData_Get_Struct(child, cmark_node, &Markly_Node_Type, node2);

	if (!cmark_node_append_child(node1, node2)) {
		rb_raise(Markly_Error, "could not append child");
	}

	return Qtrue;
}

#code_info ⇒ Object

# File 'ext/markly/markly.c', line 1042

static VALUE Markly_Node_get_code_info(VALUE self) {
	const char *code_info;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	code_info = cmark_node_get_code_info(node);

	if (code_info == NULL) {
		rb_raise(Markly_Error, "could not get code_info");
	}

	return rb_str_new2(code_info);
}

#code_info=(info) ⇒ Object

# File 'ext/markly/markly.c', line 1064

static VALUE Markly_Node_set_code_info(VALUE self, VALUE info) {
	const char *text = NULL;
	cmark_node *node;

	if (!NIL_P(info)) {
		Check_Type(info, T_STRING);
		text = StringValueCStr(info);
	}

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	if (!cmark_node_set_code_info(node, text)) {
		rb_raise(Markly_Error, "could not set code_info");
	}

	return Qnil;
}

#code_language ⇒ Object

Return the language identifier from the code info string.

# File 'lib/markly/node.rb', line 71

def code_language
	code_info.split(/\s+/, 2).first
end

#delete ⇒ Object

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

static VALUE Markly_Node_unlink(VALUE self) {
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	cmark_node_unlink(node);

	return Qnil;
}

#delete_until ⇒ Object

Delete all nodes until the block returns true.

# File 'lib/markly/node.rb', line 117

def delete_until
	current = self
	while current
		return current if yield(current)
		next_node = current.next
		current.delete
		current = next_node
	end
end

#dup ⇒ Object

Duplicate the current node and all its children.

# File 'lib/markly/node.rb', line 22

def dup
	# This is a bit crazy, but it's the best I can come up with right now:
	node = Markly.parse(self.to_markdown)
	
	# If we aren't duplicating a document, we return `first_child` as the root will be a document node:
	if self.type == :document
		return node
	else
		return node.first_child
	end
end

#each ⇒ Object

Iterate over the direct children of this node.

# File 'lib/markly/node.rb', line 89

def each
	return enum_for(:each) unless block_given?
	
	child = first_child
	while child
		next_child = child.next
		yield child
		child = next_child
	end
end

#extract_children ⇒ Object

Extract the children as a fragment.

# File 'lib/markly/node.rb', line 198

def extract_children
	fragment = Markly::Node.new(:custom_inline)
	
	while child = self.first_child
		fragment.append_child(child)
	end
	
	fragment
end

#fence ⇒ Object

# File 'ext/markly/markly.c', line 1087

static VALUE Markly_Node_get_fence(VALUE self) {
	int fence_length = 0;
	int fence_offset = 0;
	char fence_character = '\0';
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
	
	if (!cmark_node_get_fenced(node, &fence_length, &fence_offset, &fence_character)) {
		return Qnil;
	}
	
	return rb_struct_new(
		Markly_Node_Fence,
		rb_str_new(&fence_character, 1),
		INT2NUM(fence_length),
		INT2NUM(fence_offset)
	);
}

#fence_info ⇒ Object

# File 'ext/markly/markly.c', line 999

static VALUE Markly_Node_get_fence_info(VALUE self) {
	const char *fence_info;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	fence_info = cmark_node_get_fence_info(node);

	if (fence_info == NULL) {
		rb_raise(Markly_Error, "could not get fence_info");
	}

	return rb_str_new2(fence_info);
}

#fence_info=(info) ⇒ Object

# File 'ext/markly/markly.c', line 1020

static VALUE Markly_Node_set_fence_info(VALUE self, VALUE info) {
	char *text;
	cmark_node *node;
	Check_Type(info, T_STRING);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
	text = StringValueCStr(info);

	if (!cmark_node_set_fence_info(node, text)) {
		rb_raise(Markly_Error, "could not set fence_info");
	}

	return Qnil;
}

#find_header(title) ⇒ Object

Finds a direct child header with the given text.

# File 'lib/markly/node.rb', line 104

def find_header(title)
	each do |child|
		if child.type == :header && child.first_child.string_content == title
			return child
		end
	end
end

#first_child ⇒ Object

# File 'ext/markly/markly.c', line 489

static VALUE Markly_Node_first_child(VALUE self) {
	cmark_node *node, *child;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	child = cmark_node_first_child(node);

	return Markly_Node_wrap(child);
}

#header_level ⇒ Object

# File 'ext/markly/markly.c', line 820

static VALUE Markly_Node_get_header_level(VALUE self) {
	int header_level;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	header_level = cmark_node_get_header_level(node);

	if (header_level == 0) {
		rb_raise(Markly_Error, "could not get header_level");
	}

	return INT2NUM(header_level);
}

#header_level=(level) ⇒ Object

# File 'ext/markly/markly.c', line 841

static VALUE Markly_Node_set_header_level(VALUE self, VALUE level) {
	int l;
	cmark_node *node;
	Check_Type(level, T_FIXNUM);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
	l = FIX2INT(level);

	if (!cmark_node_set_header_level(node, l)) {
		rb_raise(Markly_Error, "could not set header_level");
	}

	return Qnil;
}

#html_escape_href(rb_text) ⇒ Object

# File 'ext/markly/markly.c', line 1184

static VALUE Markly_Node_html_escape_href(VALUE self, VALUE rb_text) {
	char *result;
	cmark_node *node;
	Check_Type(rb_text, T_STRING);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, 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),
													(bufsize_t)RSTRING_LEN(rb_text))) {
		result = (char *)cmark_strbuf_detach(&buf);
		return rb_str_new2(result);
	}

	return rb_text;
}

#html_escape_html(rb_text) ⇒ Object

# File 'ext/markly/markly.c', line 1204

static VALUE Markly_Node_html_escape_html(VALUE self, VALUE rb_text) {
	char *result;
	cmark_node *node;
	Check_Type(rb_text, T_STRING);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, 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),
													 (bufsize_t)RSTRING_LEN(rb_text), 0)) {
		result = (char *)cmark_strbuf_detach(&buf);
		return rb_str_new2(result);
	}

	return rb_text;
}

#insert_after(sibling) ⇒ Object

# File 'ext/markly/markly.c', line 641

static VALUE Markly_Node_insert_after(VALUE self, VALUE sibling) {
	cmark_node *node1, *node2;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node1);
	TypedData_Get_Struct(sibling, cmark_node, &Markly_Node_Type, node2);

	if (!cmark_node_insert_after(node1, node2)) {
		rb_raise(Markly_Error, "could not insert after");
	}

	return Qtrue;
}

#insert_before(sibling) ⇒ Object

# File 'ext/markly/markly.c', line 519

static VALUE Markly_Node_insert_before(VALUE self, VALUE sibling) {
	cmark_node *node1, *node2;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node1);
	TypedData_Get_Struct(sibling, cmark_node, &Markly_Node_Type, node2);

	if (!cmark_node_insert_before(node1, node2)) {
		rb_raise(Markly_Error, "could not insert before");
	}

	return Qtrue;
}

#last_child ⇒ Object

# File 'ext/markly/markly.c', line 697

static VALUE Markly_Node_last_child(VALUE self) {
	cmark_node *node, *child;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	child = cmark_node_last_child(node);

	return Markly_Node_wrap(child);
}

#list_start ⇒ Object

# File 'ext/markly/markly.c', line 917

static VALUE Markly_Node_get_list_start(VALUE self) {
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	if (cmark_node_get_type(node) != CMARK_NODE_LIST ||
			cmark_node_get_list_type(node) != CMARK_ORDERED_LIST) {
		rb_raise(Markly_Error, "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

# File 'ext/markly/markly.c', line 938

static VALUE Markly_Node_set_list_start(VALUE self, VALUE start) {
	int s;
	cmark_node *node;
	Check_Type(start, T_FIXNUM);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
	s = FIX2INT(start);

	if (!cmark_node_set_list_start(node, s)) {
		rb_raise(Markly_Error, "could not set list_start");
	}

	return Qnil;
}

#list_tight ⇒ Object

# File 'ext/markly/markly.c', line 959

static VALUE Markly_Node_get_list_tight(VALUE self) {
	int flag;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	if (cmark_node_get_type(node) != CMARK_NODE_LIST) {
		rb_raise(Markly_Error, "can't get list_tight for non-list");
	}

	flag = cmark_node_get_list_tight(node);

	return flag ? Qtrue : Qfalse;
}

#list_tight=(tight) ⇒ Object

# File 'ext/markly/markly.c', line 980

static VALUE Markly_Node_set_list_tight(VALUE self, VALUE tight) {
	int t;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
	t = RTEST(tight);

	if (!cmark_node_set_list_tight(node, t)) {
		rb_raise(Markly_Error, "could not set list_tight");
	}

	return Qnil;
}

#list_type ⇒ Object

# File 'ext/markly/markly.c', line 862

static VALUE Markly_Node_get_list_type(VALUE self) {
	int list_type;
	cmark_node *node;
	VALUE symbol;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, 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(Markly_Error, "could not get list_type");
	}

	return symbol;
}

#list_type=(list_type) ⇒ Object

# File 'ext/markly/markly.c', line 888

static VALUE Markly_Node_set_list_type(VALUE self, VALUE list_type) {
	int type = 0;
	cmark_node *node;
	Check_Type(list_type, T_SYMBOL);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, 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(Markly_Error, "invalid list_type");
	}

	if (!cmark_node_set_list_type(node, type)) {
		rb_raise(Markly_Error, "could not set list_type");
	}

	return Qnil;
}

#next ⇒ Object

# File 'ext/markly/markly.c', line 502

static VALUE Markly_Node_next(VALUE self) {
	cmark_node *node, *next;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	next = cmark_node_next(node);

	return Markly_Node_wrap(next);
}

#next_header ⇒ Object Also known as: next_heading

Finds the next sibling header.

# File 'lib/markly/node.rb', line 145

def next_header
	current = self.next
	while current
		if current.type == :header
			return current
		end
		current = current.next
	end
end

#parent ⇒ Object

# File 'ext/markly/markly.c', line 710

static VALUE Markly_Node_parent(VALUE self) {
	cmark_node *node, *parent;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	parent = cmark_node_parent(node);

	return Markly_Node_wrap(parent);
}

#parent_footnote_def ⇒ Object

# File 'ext/markly/markly.c', line 1145

static VALUE Markly_Node_get_parent_footnote_def(VALUE self) {
	cmark_node *node;
	cmark_node *parent;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	parent = cmark_node_parent_footnote_def(node);

	return Markly_Node_wrap(parent);
}

#prepend_child(child) ⇒ Object

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

static VALUE Markly_Node_prepend_child(VALUE self, VALUE child) {
	cmark_node *node1, *node2;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node1);
	TypedData_Get_Struct(child, cmark_node, &Markly_Node_Type, node2);

	if (!cmark_node_prepend_child(node1, node2)) {
		rb_raise(Markly_Error, "could not prepend child");
	}

	return Qtrue;
}

#previous ⇒ Object

# File 'ext/markly/markly.c', line 723

static VALUE Markly_Node_previous(VALUE self) {
	cmark_node *node, *previous;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	previous = cmark_node_previous(node);

	return Markly_Node_wrap(previous);
}

#replace(other) ⇒ Object

# File 'ext/markly/markly.c', line 274

static VALUE Markly_Node_replace(VALUE self, VALUE other) {
	cmark_node *current_node = NULL, *replacement_node = NULL;
	
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, current_node);
	TypedData_Get_Struct(other, cmark_node, &Markly_Node_Type, replacement_node);
	
	int result = cmark_node_replace(current_node, replacement_node);
	
	if (result == 0) {
		rb_raise(Markly_Error, "could not replace node");
	}
	
	return other;
}

#replace_section(new_node, replace_header: true, remove_subsections: true) ⇒ Object

Replace a section (header + content) with a new node.

# File 'lib/markly/node.rb', line 132

def replace_section(new_node, replace_header: true, remove_subsections: true)
	# Delete until the next heading:
	self.next&.delete_until do |node|
		node.type == :header && (!remove_subsections || node.header_level <= self.header_level)
	end
	
	self.append_after(new_node) if new_node
	self.delete if replace_header
end

#source_position ⇒ Object

# File 'ext/markly/markly.c', line 439

static VALUE Markly_Node_get_source_position(VALUE self) {
	int start_line, start_column, end_line, end_column;
	VALUE result;

	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, 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

# File 'ext/markly/markly.c', line 301

static VALUE Markly_Node_get_string_content(VALUE self) {
	const char *text;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	text = cmark_node_get_literal(node);

	if (text == NULL) {
		return RUBY_Qnil;
	}

	return encode_utf8_string(text);
}

#string_content=(s) ⇒ Object

# File 'ext/markly/markly.c', line 322

static VALUE Markly_Node_set_string_content(VALUE self, VALUE s) {
	char *text;
	cmark_node *node;
	Check_Type(s, T_STRING);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
	text = StringValueCStr(s);

	if (!cmark_node_set_literal(node, text)) {
		rb_raise(Markly_Error, "could not set string content");
	}

	return Qnil;
}

#table_alignments ⇒ Object

# File 'ext/markly/markly.c', line 1155

static VALUE Markly_Node_get_table_alignments(VALUE self) {
	uint16_t column_count, i;
	uint8_t *alignments;
	cmark_node *node;
	VALUE ary;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	column_count = cmark_gfm_extensions_get_table_columns(node);
	alignments = cmark_gfm_extensions_get_table_alignments(node);

	if (!column_count || !alignments) {
		rb_raise(Markly_Error, "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;
}

#tasklist_item_checked=(item_checked) ⇒ Object

# File 'ext/markly/markly.c', line 1128

static VALUE Markly_Node_set_tasklist_item_checked(VALUE self, VALUE item_checked) {
	int tasklist_state;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
	tasklist_state = RTEST(item_checked);

	if (!cmark_gfm_extensions_set_tasklist_item_checked(node, tasklist_state)) {
		rb_raise(Markly_Error, "could not set tasklist_item_checked");
	};

	if (tasklist_state) {
		return Qtrue;
	} else {
		return Qfalse;
	}
}

#tasklist_item_checked? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/markly/markly.c', line 1106

static VALUE Markly_Node_tasklist_item_checked_p(VALUE self) {
	int tasklist_state;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	tasklist_state = cmark_gfm_extensions_get_tasklist_item_checked(node);

	if (tasklist_state == 1) {
		return Qtrue;
	} else {
		return Qfalse;
	}
}

#title ⇒ Object

# File 'ext/markly/markly.c', line 779

static VALUE Markly_Node_get_title(VALUE self) {
	const char *text;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	text = cmark_node_get_title(node);
	if (text == NULL) {
		rb_raise(Markly_Error, "could not get title");
	}

	return rb_str_new2(text);
}

#title=(title) ⇒ Object

# File 'ext/markly/markly.c', line 799

static VALUE Markly_Node_set_title(VALUE self, VALUE title) {
	char *text;
	cmark_node *node;
	Check_Type(title, T_STRING);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
	text = StringValueCStr(title);

	if (!cmark_node_set_title(node, text)) {
		rb_raise(Markly_Error, "could not set title");
	}

	return Qnil;
}

#to_commonmark(flags: DEFAULT, width: 0) ⇒ Object Also known as: to_markdown

Convert the node to a CommonMark string.

# File 'lib/markly/node.rb', line 62

def to_commonmark(flags: DEFAULT, width: 0)
	_render_commonmark(flags, width).force_encoding("utf-8")
end

#to_html(flags: DEFAULT, extensions: []) ⇒ Object

Convert the node to an HTML string.

# File 'lib/markly/node.rb', line 53

def to_html(flags: DEFAULT, extensions: [])
	_render_html(flags, extensions).force_encoding("utf-8")
end

#to_plaintext(flags: DEFAULT, width: 0) ⇒ Object

Convert the node to a plain-text string.

# File 'lib/markly/node.rb', line 80

def to_plaintext(flags: DEFAULT, width: 0)
	_render_plaintext(flags, width).force_encoding("utf-8")
end

#type ⇒ Object

# File 'ext/markly/markly.c', line 342

static VALUE Markly_Node_get_type(VALUE self) {
	int node_type = 0;
	cmark_node *node = NULL;
	VALUE symbol = Qnil;
	const char *s = NULL;

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	node_type = cmark_node_get_type(node);
	symbol = Qnil;

	switch (node_type) {
	case CMARK_NODE_DOCUMENT:
		symbol = sym_document;
		break;
	case CMARK_NODE_CUSTOM_BLOCK:
		symbol = sym_custom_block;
		break;
	case CMARK_NODE_CUSTOM_INLINE:
		symbol = sym_custom_inline;
		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;
	case CMARK_NODE_FRONT_MATTER:
		symbol = sym_front_matter;
		break;
	default:
		if (node->extension) {
			s = node->extension->get_type_string_func(node->extension, node);
			return ID2SYM(rb_intern(s));
		}
		rb_raise(Markly_Error, "invalid node type %d", node_type);
	}

	return symbol;
}

#type_string ⇒ Object

# File 'ext/markly/markly.c', line 465

static VALUE Markly_Node_get_type_string(VALUE self) {
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	return rb_str_new2(cmark_node_get_type_string(node));
}

#url ⇒ Object

# File 'ext/markly/markly.c', line 738

static VALUE Markly_Node_get_url(VALUE self) {
	const char *text;
	cmark_node *node;
	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);

	text = cmark_node_get_url(node);
	if (text == NULL) {
		rb_raise(Markly_Error, "could not get url");
	}

	return rb_str_new2(text);
}

#url=(url) ⇒ Object

# File 'ext/markly/markly.c', line 758

static VALUE Markly_Node_set_url(VALUE self, VALUE url) {
	cmark_node *node;
	char *text;
	Check_Type(url, T_STRING);

	TypedData_Get_Struct(self, cmark_node, &Markly_Node_Type, node);
	text = StringValueCStr(url);

	if (!cmark_node_set_url(node, text)) {
		rb_raise(Markly_Error, "could not set url");
	}

	return Qnil;
}

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

Walk the node tree recursively.

Yields:

• (_self)

Yield Parameters:

• _self (Markly::Node) —

  the object that the method was called on

# File 'lib/markly/node.rb', line 39

def walk(&block)
	return enum_for(:walk) unless block_given?
	
	yield self
	each do |child|
		child.walk(&block)
	end
end