class CommonMarker::Node

Public Class Methods

markdown_to_html(p1, p2, p3) click to toggle source

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;
}
new(p1) click to toggle source

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);
}
parse_document(p1, p2, p3, p4) click to toggle source

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

_render_commonmark(p1, p2 = v2) click to toggle source

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;
}
_render_html(p1, p2) click to toggle source

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;
}
_render_plaintext(p1, p2 = v2) click to toggle source

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;
}
append_child(p1) click to toggle source

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;
}
delete() click to toggle source

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;
}
each() { |child| ... } click to toggle source

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
each_child(&block) click to toggle source

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
fence_info() click to toggle source

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);
}
fence_info=(p1) click to toggle source

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;
}
first_child() click to toggle source

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);
}
header_level() click to toggle source

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);
}
header_level=(p1) click to toggle source

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;
}
html_escape_href(p1) click to toggle source

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;
}
html_escape_html(p1) click to toggle source

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;
}
insert_after(p1) click to toggle source

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;
}
insert_before(p1) click to toggle source

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;
}
last_child() click to toggle source

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);
}
list_start() click to toggle source

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));
}
list_start=(p1) click to toggle source

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;
}
list_tight() click to toggle source

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;
}
list_tight=(p1) click to toggle source

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;
}
list_type() click to toggle source

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;
}
list_type=(p1) click to toggle source

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;
}
next() click to toggle source

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);
}
parent() click to toggle source

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);
}
prepend_child(p1) click to toggle source

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;
}
previous() click to toggle source

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);
}
sourcepos() click to toggle source

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;
}
string_content() click to toggle source

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);
}
string_content=(p1) click to toggle source

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;
}
table_alignments() click to toggle source
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;
}
title() click to toggle source

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);
}
title=(p1) click to toggle source

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;
}
to_commonmark(options = :DEFAULT, width = 120) click to toggle source

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
to_html(options = :DEFAULT, extensions = []) click to toggle source

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
to_plaintext(options = :DEFAULT, width = 120) click to toggle source

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
type() click to toggle source

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;
}
type_string() click to toggle source

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));
}
url() click to toggle source

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);
}
url=(p1) click to toggle source

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;
}
walk() { |self| ... } click to toggle source

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