`class Node`

Nested

::Inspect

Definitions

`def walk(&block)`

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

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

Implementation

def walk(&block)
	return enum_for(:walk) unless block_given?

	yield self
	each do |child|
		child.walk(&block)
	end
end

`def to_html(flags: DEFAULT, extensions: [])`

Public: Convert the node to an HTML string.

options - A Symbol or Array of Symbols indicating the render options extensions - An Array of Symbols indicating the extensions to use

Returns a String.

Implementation

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

`def to_commonmark(flags: DEFAULT, width: 0)`

Public: Convert the node to a CommonMark string.

options - A Symbol or Array of Symbols indicating the render options width - Column to wrap the output at

Returns a String.

Implementation

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

`def to_plaintext(flags: DEFAULT, width: 0)`

Public: Convert the node to a plain text string.

options - A Symbol or Array of Symbols indicating the render options width - Column to wrap the output at

Returns a String.

Implementation

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

`def each`

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

Implementation

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

`def delete_until`

Delete all nodes until the block returns true.

Signature

returns　Markly::Node: the node that returned true.

Implementation

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

`def replace_section(new_node, replace_header: true, remove_subsections: true)`

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

Signature

parameter　title　String: the title of the section to replace.
parameter　new_node　Markly::Node: the node to replace the section with.
parameter　replace_header　Boolean: whether to replace the header itself or not.
parameter　remove_subsections　Boolean: whether to remove subsections or not.

Implementation

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

`def append_after(node)`

Append the given node after the current node.

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

Signature

parameter　node　Markly::Node: the node to append.

Implementation

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

`def extract_children`

Extract the children as a fragment.

Signature

returns　Markly::Node: the fragment.

Implementation

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